libMesh: libMesh::FE< Dim, T > Class Template Reference

Definition: enum_fe_family.h:72

template<>

FEContinuity libMesh::FE< 1, SCALAR >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 108 of file fe_scalar.C.

References libMesh::DISCONTINUOUS.

108 { return DISCONTINUOUS; }

Definition: enum_fe_family.h:72

template<>

FEContinuity libMesh::FE< 2, SCALAR >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 109 of file fe_scalar.C.

References libMesh::DISCONTINUOUS.

109 { return DISCONTINUOUS; }

Definition: enum_fe_family.h:72

template<>

FEContinuity libMesh::FE< 3, SCALAR >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 110 of file fe_scalar.C.

References libMesh::DISCONTINUOUS.

110 { return DISCONTINUOUS; }

Definition: enum_fe_family.h:72

template<>

FEContinuity libMesh::FE< 0, L2_HIERARCHIC >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 194 of file fe_l2_hierarchic.C.

References libMesh::DISCONTINUOUS.

194 { return DISCONTINUOUS; }

Definition: enum_fe_family.h:72

template<>

FEContinuity libMesh::FE< 1, L2_HIERARCHIC >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 195 of file fe_l2_hierarchic.C.

References libMesh::DISCONTINUOUS.

195 { return DISCONTINUOUS; }

Definition: enum_fe_family.h:72

template<>

FEContinuity libMesh::FE< 2, L2_HIERARCHIC >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 196 of file fe_l2_hierarchic.C.

References libMesh::DISCONTINUOUS.

196 { return DISCONTINUOUS; }

Definition: enum_fe_family.h:72

template<>

FEContinuity libMesh::FE< 3, L2_HIERARCHIC >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 197 of file fe_l2_hierarchic.C.

References libMesh::DISCONTINUOUS.

197 { return DISCONTINUOUS; }

Definition: enum_fe_family.h:72

template<unsigned int Dim, FEFamily T>

virtual FEContinuity libMesh::FE< Dim, T >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

template<>

FEContinuity libMesh::FE< 0, CLOUGH >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 299 of file fe_clough.C.

References libMesh::C_ONE.

299 { return C_ONE; }

Definition: enum_fe_family.h:74

template<>

FEContinuity libMesh::FE< 1, CLOUGH >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 300 of file fe_clough.C.

References libMesh::C_ONE.

300 { return C_ONE; }

Definition: enum_fe_family.h:74

template<>

FEContinuity libMesh::FE< 2, CLOUGH >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 301 of file fe_clough.C.

References libMesh::C_ONE.

301 { return C_ONE; }

Definition: enum_fe_family.h:74

template<>

FEContinuity libMesh::FE< 3, CLOUGH >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 302 of file fe_clough.C.

References libMesh::C_ONE.

302 { return C_ONE; }

Definition: enum_fe_family.h:74

template<>

FEContinuity libMesh::FE< 0, HERMITE >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 339 of file fe_hermite.C.

References libMesh::C_ONE.

339 { return C_ONE; }

Definition: enum_fe_family.h:74

template<>

FEContinuity libMesh::FE< 1, HERMITE >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 340 of file fe_hermite.C.

References libMesh::C_ONE.

340 { return C_ONE; }

Definition: enum_fe_family.h:74

template<>

FEContinuity libMesh::FE< 2, HERMITE >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 341 of file fe_hermite.C.

References libMesh::C_ONE.

341 { return C_ONE; }

Definition: enum_fe_family.h:74

template<>

FEContinuity libMesh::FE< 3, HERMITE >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 342 of file fe_hermite.C.

References libMesh::C_ONE.

342 { return C_ONE; }

Definition: enum_fe_family.h:74

template<>

FEContinuity libMesh::FE< 0, HIERARCHIC >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 367 of file fe_hierarchic.C.

References libMesh::C_ZERO.

367 { return C_ZERO; }

Definition: enum_fe_family.h:73

template<>

FEContinuity libMesh::FE< 1, HIERARCHIC >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 368 of file fe_hierarchic.C.

References libMesh::C_ZERO.

368 { return C_ZERO; }

Definition: enum_fe_family.h:73

template<>

FEContinuity libMesh::FE< 2, HIERARCHIC >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 369 of file fe_hierarchic.C.

References libMesh::C_ZERO.

369 { return C_ZERO; }

Definition: enum_fe_family.h:73

template<>

FEContinuity libMesh::FE< 3, HIERARCHIC >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 370 of file fe_hierarchic.C.

References libMesh::C_ZERO.

370 { return C_ZERO; }

Definition: enum_fe_family.h:73

template<>

FEContinuity libMesh::FE< 0, MONOMIAL >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 400 of file fe_monomial.C.

References libMesh::DISCONTINUOUS.

400 { return DISCONTINUOUS; }

Definition: enum_fe_family.h:72

template<>

FEContinuity libMesh::FE< 1, MONOMIAL >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 401 of file fe_monomial.C.

References libMesh::DISCONTINUOUS.

401 { return DISCONTINUOUS; }

Definition: enum_fe_family.h:72

template<>

FEContinuity libMesh::FE< 2, MONOMIAL >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 402 of file fe_monomial.C.

References libMesh::DISCONTINUOUS.

402 { return DISCONTINUOUS; }

Definition: enum_fe_family.h:72

template<>

FEContinuity libMesh::FE< 3, MONOMIAL >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 403 of file fe_monomial.C.

References libMesh::DISCONTINUOUS.

403 { return DISCONTINUOUS; }

Definition: enum_fe_family.h:72

template<>

FEContinuity libMesh::FE< 0, BERNSTEIN >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 430 of file fe_bernstein.C.

References libMesh::C_ZERO.

430 { return C_ZERO; }

Definition: enum_fe_family.h:73

template<>

FEContinuity libMesh::FE< 1, BERNSTEIN >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 431 of file fe_bernstein.C.

References libMesh::C_ZERO.

431 { return C_ZERO; }

Definition: enum_fe_family.h:73

template<>

FEContinuity libMesh::FE< 2, BERNSTEIN >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 432 of file fe_bernstein.C.

References libMesh::C_ZERO.

432 { return C_ZERO; }

Definition: enum_fe_family.h:73

template<>

FEContinuity libMesh::FE< 3, BERNSTEIN >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 433 of file fe_bernstein.C.

References libMesh::C_ZERO.

433 { return C_ZERO; }

Definition: enum_fe_family.h:73

template<>

FEContinuity libMesh::FE< 0, L2_LAGRANGE >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 475 of file fe_l2_lagrange.C.

References libMesh::DISCONTINUOUS.

475 { return DISCONTINUOUS; }

Definition: enum_fe_family.h:72

template<>

FEContinuity libMesh::FE< 1, L2_LAGRANGE >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 476 of file fe_l2_lagrange.C.

References libMesh::DISCONTINUOUS.

476 { return DISCONTINUOUS; }

Definition: enum_fe_family.h:72

template<>

FEContinuity libMesh::FE< 2, L2_LAGRANGE >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 477 of file fe_l2_lagrange.C.

References libMesh::DISCONTINUOUS.

477 { return DISCONTINUOUS; }

Definition: enum_fe_family.h:72

template<>

FEContinuity libMesh::FE< 3, L2_LAGRANGE >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 478 of file fe_l2_lagrange.C.

References libMesh::DISCONTINUOUS.

478 { return DISCONTINUOUS; }

Definition: enum_fe_family.h:72

template<>

FEContinuity libMesh::FE< 0, NEDELEC_ONE >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 550 of file fe_nedelec_one.C.

550 { NEDELEC_LOW_D_ERROR_MESSAGE }

template<>

FEContinuity libMesh::FE< 1, NEDELEC_ONE >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 551 of file fe_nedelec_one.C.

551 { NEDELEC_LOW_D_ERROR_MESSAGE }

template<>

FEContinuity libMesh::FE< 2, NEDELEC_ONE >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 552 of file fe_nedelec_one.C.

References libMesh::H_CURL.

552 { return H_CURL; }

libMesh::H_CURL

Definition: enum_fe_family.h:75

template<>

FEContinuity libMesh::FE< 3, NEDELEC_ONE >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 553 of file fe_nedelec_one.C.

References libMesh::H_CURL.

553 { return H_CURL; }

libMesh::H_CURL

Definition: enum_fe_family.h:75

template<>

FEContinuity libMesh::FE< 0, LAGRANGE >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 878 of file fe_lagrange.C.

References libMesh::C_ZERO.

878 { return C_ZERO; }

Definition: enum_fe_family.h:73

template<>

FEContinuity libMesh::FE< 1, LAGRANGE >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 879 of file fe_lagrange.C.

References libMesh::C_ZERO.

879 { return C_ZERO; }

Definition: enum_fe_family.h:73

template<>

FEContinuity libMesh::FE< 2, LAGRANGE >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 880 of file fe_lagrange.C.

References libMesh::C_ZERO.

880 { return C_ZERO; }

Definition: enum_fe_family.h:73

template<>

FEContinuity libMesh::FE< 3, LAGRANGE >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 881 of file fe_lagrange.C.

References libMesh::C_ZERO.

881 { return C_ZERO; }

Definition: enum_fe_family.h:73

template<>

FEContinuity libMesh::FE< 0, XYZ >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 915 of file fe_xyz.C.

References libMesh::DISCONTINUOUS.

915 { return DISCONTINUOUS; }

Definition: enum_fe_family.h:72

template<>

FEContinuity libMesh::FE< 1, XYZ >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 916 of file fe_xyz.C.

References libMesh::DISCONTINUOUS.

916 { return DISCONTINUOUS; }

Definition: enum_fe_family.h:72

template<>

FEContinuity libMesh::FE< 2, XYZ >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 917 of file fe_xyz.C.

References libMesh::DISCONTINUOUS.

917 { return DISCONTINUOUS; }

Definition: enum_fe_family.h:72

template<>

FEContinuity libMesh::FE< 3, XYZ >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 918 of file fe_xyz.C.

References libMesh::DISCONTINUOUS.

918 { return DISCONTINUOUS; }

Definition: enum_fe_family.h:72

template<>

FEContinuity libMesh::FE< 0, LAGRANGE_VEC >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 927 of file fe_lagrange_vec.C.

References libMesh::C_ZERO.

927 { return C_ZERO; }

Definition: enum_fe_family.h:73

template<>

FEContinuity libMesh::FE< 2, SUBDIVISION >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 928 of file fe_subdivision_2D.C.

References libMesh::C_ONE.

928 { return C_ONE; }

Definition: enum_fe_family.h:74

template<>

FEContinuity libMesh::FE< 1, LAGRANGE_VEC >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 928 of file fe_lagrange_vec.C.

References libMesh::C_ZERO.

928 { return C_ZERO; }

Definition: enum_fe_family.h:73

template<>

FEContinuity libMesh::FE< 2, LAGRANGE_VEC >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 929 of file fe_lagrange_vec.C.

References libMesh::C_ZERO.

929 { return C_ZERO; }

Definition: enum_fe_family.h:73

template<>

FEContinuity libMesh::FE< 3, LAGRANGE_VEC >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 930 of file fe_lagrange_vec.C.

References libMesh::C_ZERO.

930 { return C_ZERO; }

Definition: enum_fe_family.h:73

template<>

FEContinuity libMesh::FE< 0, SZABAB >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 1279 of file fe_szabab.C.

References libMesh::C_ZERO.

1279 { return C_ZERO; }

Definition: enum_fe_family.h:73

template<>

FEContinuity libMesh::FE< 1, SZABAB >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 1280 of file fe_szabab.C.

References libMesh::C_ZERO.

1280 { return C_ZERO; }

Definition: enum_fe_family.h:73

template<>

FEContinuity libMesh::FE< 2, SZABAB >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 1281 of file fe_szabab.C.

References libMesh::C_ZERO.

1281 { return C_ZERO; }

Definition: enum_fe_family.h:73

template<>

FEContinuity libMesh::FE< 3, SZABAB >::get_continuity ( ) const

virtual

Returns: The continuity level of the finite element.

Implements libMesh::FEAbstract.

Definition at line 1282 of file fe_szabab.C.

References libMesh::C_ZERO.

1282 { return C_ZERO; }

libMesh::FEAbstract::calculate_curl_phi

Definition: enum_fe_family.h:73

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_curl_phi ( ) const

inlineinherited

Returns: The curl of the shape function at the quadrature points.

Definition at line 224 of file fe_base.h.

References libMesh::FEAbstract::calculate_curl_phi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< OutputType >::curl_phi, and libMesh::libmesh_assert().

225 { libmesh_assert(!calculations_started || calculate_curl_phi);

226 calculate_curl_phi = calculate_dphiref = true; return curl_phi; }

bool calculate_curl_phi

Definition: fe_abstract.h:543

libMesh::FEGenericBase< FEOutputType< T >::type >::curl_phi

bool calculations_started

Definition: fe_abstract.h:523

std::vector< std::vector< OutputShape > > curl_phi

Definition: fe_base.h:509

libmesh_assert(j)

bool calculate_dphiref

Definition: fe_abstract.h:553

const std::vector<Real>& libMesh::FEAbstract::get_curvatures ( ) const

inlineinherited

Returns: The curvatures for use in face integration.

Definition at line 377 of file fe_abstract.h.

References libMesh::FEAbstract::_fe_map, libMesh::FEAbstract::attach_quadrature_rule(), libMesh::FEAbstract::n_quadrature_points(), and libMesh::FEAbstract::n_shape_functions().

378 { return this->_fe_map->get_curvatures();}

UniquePtr< FEMap > _fe_map

Definition: fe_abstract.h:511

const std::vector<std::vector<OutputTensor> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phi ( ) const

inlineinherited

Returns: The shape function second derivatives at the quadrature points.

Definition at line 290 of file fe_base.h.

References libMesh::FEAbstract::calculate_d2phi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< OutputType >::d2phi, and libMesh::libmesh_assert().

291 { libmesh_assert(!calculations_started || calculate_d2phi);

292 calculate_d2phi = calculate_dphiref = true; return d2phi; }

libMesh::FEGenericBase< FEOutputType< T >::type >::d2phi

bool calculate_d2phi

Definition: fe_abstract.h:538

std::vector< std::vector< OutputTensor > > d2phi

Definition: fe_base.h:552

bool calculations_started

Definition: fe_abstract.h:523

libmesh_assert(j)

bool calculate_dphiref

Definition: fe_abstract.h:553

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phideta2 ( ) const

inlineinherited

Returns: The shape function second derivatives at the quadrature points, in reference coordinates

Definition at line 370 of file fe_base.h.

References libMesh::FEAbstract::calculate_d2phi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< OutputType >::d2phideta2, and libMesh::libmesh_assert().

371 { libmesh_assert(!calculations_started || calculate_d2phi);

372 calculate_d2phi = calculate_dphiref = true; return d2phideta2; }

bool calculate_d2phi

Definition: fe_abstract.h:538

bool calculations_started

Definition: fe_abstract.h:523

libMesh::FEGenericBase< FEOutputType< T >::type >::d2phideta2

libmesh_assert(j)

std::vector< std::vector< OutputShape > > d2phideta2

Definition: fe_base.h:572

bool calculate_dphiref

Definition: fe_abstract.h:553

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidetadzeta ( ) const

inlineinherited

Returns: The shape function second derivatives at the quadrature points, in reference coordinates

Definition at line 378 of file fe_base.h.

References libMesh::FEAbstract::calculate_d2phi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< OutputType >::d2phidetadzeta, and libMesh::libmesh_assert().

379 { libmesh_assert(!calculations_started || calculate_d2phi);

380 calculate_d2phi = calculate_dphiref = true; return d2phidetadzeta; }

bool calculate_d2phi

Definition: fe_abstract.h:538

bool calculations_started

Definition: fe_abstract.h:523

libMesh::FEGenericBase< FEOutputType< T >::type >::d2phidetadzeta

libmesh_assert(j)

std::vector< std::vector< OutputShape > > d2phidetadzeta

Definition: fe_base.h:577

bool calculate_dphiref

Definition: fe_abstract.h:553

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidx2 ( ) const

inlineinherited

Returns: The shape function second derivatives at the quadrature points.

Definition at line 298 of file fe_base.h.

References libMesh::FEAbstract::calculate_d2phi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< OutputType >::d2phidx2, and libMesh::libmesh_assert().

299 { libmesh_assert(!calculations_started || calculate_d2phi);

300 calculate_d2phi = calculate_dphiref = true; return d2phidx2; }

bool calculate_d2phi

Definition: fe_abstract.h:538

libMesh::FEGenericBase< FEOutputType< T >::type >::d2phidx2

bool calculations_started

Definition: fe_abstract.h:523

std::vector< std::vector< OutputShape > > d2phidx2

Definition: fe_base.h:587

libmesh_assert(j)

bool calculate_dphiref

Definition: fe_abstract.h:553

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidxdy ( ) const

inlineinherited

Returns: The shape function second derivatives at the quadrature points.

Definition at line 306 of file fe_base.h.

References libMesh::FEAbstract::calculate_d2phi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< OutputType >::d2phidxdy, and libMesh::libmesh_assert().

307 { libmesh_assert(!calculations_started || calculate_d2phi);

308 calculate_d2phi = calculate_dphiref = true; return d2phidxdy; }

bool calculate_d2phi

Definition: fe_abstract.h:538

bool calculations_started

Definition: fe_abstract.h:523

libMesh::FEGenericBase< FEOutputType< T >::type >::d2phidxdy

libmesh_assert(j)

std::vector< std::vector< OutputShape > > d2phidxdy

Definition: fe_base.h:592

bool calculate_dphiref

Definition: fe_abstract.h:553

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidxdz ( ) const

inlineinherited

Returns: The shape function second derivatives at the quadrature points.

Definition at line 314 of file fe_base.h.

References libMesh::FEAbstract::calculate_d2phi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< OutputType >::d2phidxdz, and libMesh::libmesh_assert().

315 { libmesh_assert(!calculations_started || calculate_d2phi);

316 calculate_d2phi = calculate_dphiref = true; return d2phidxdz; }

libMesh::FEGenericBase< FEOutputType< T >::type >::d2phidxdz

bool calculate_d2phi

Definition: fe_abstract.h:538

std::vector< std::vector< OutputShape > > d2phidxdz

Definition: fe_base.h:597

bool calculations_started

Definition: fe_abstract.h:523

libmesh_assert(j)

bool calculate_dphiref

Definition: fe_abstract.h:553

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidxi2 ( ) const

inlineinherited

Returns: The shape function second derivatives at the quadrature points, in reference coordinates

Definition at line 346 of file fe_base.h.

References libMesh::FEAbstract::calculate_d2phi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< OutputType >::d2phidxi2, and libMesh::libmesh_assert().

347 { libmesh_assert(!calculations_started || calculate_d2phi);

348 calculate_d2phi = calculate_dphiref = true; return d2phidxi2; }

bool calculate_d2phi

Definition: fe_abstract.h:538

bool calculations_started

Definition: fe_abstract.h:523

libmesh_assert(j)

libMesh::FEGenericBase< FEOutputType< T >::type >::d2phidxi2

bool calculate_dphiref

Definition: fe_abstract.h:553

std::vector< std::vector< OutputShape > > d2phidxi2

Definition: fe_base.h:557

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidxideta ( ) const

inlineinherited

Returns: The shape function second derivatives at the quadrature points, in reference coordinates

Definition at line 354 of file fe_base.h.

References libMesh::FEAbstract::calculate_d2phi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< OutputType >::d2phidxideta, and libMesh::libmesh_assert().

355 { libmesh_assert(!calculations_started || calculate_d2phi);

356 calculate_d2phi = calculate_dphiref = true; return d2phidxideta; }

bool calculate_d2phi

Definition: fe_abstract.h:538

libMesh::FEGenericBase< FEOutputType< T >::type >::d2phidxideta

bool calculations_started

Definition: fe_abstract.h:523

std::vector< std::vector< OutputShape > > d2phidxideta

Definition: fe_base.h:562

libmesh_assert(j)

bool calculate_dphiref

Definition: fe_abstract.h:553

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidxidzeta ( ) const

inlineinherited

Returns: The shape function second derivatives at the quadrature points, in reference coordinates

Definition at line 362 of file fe_base.h.

References libMesh::FEAbstract::calculate_d2phi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< OutputType >::d2phidxidzeta, and libMesh::libmesh_assert().

363 { libmesh_assert(!calculations_started || calculate_d2phi);

364 calculate_d2phi = calculate_dphiref = true; return d2phidxidzeta; }

bool calculate_d2phi

Definition: fe_abstract.h:538

bool calculations_started

Definition: fe_abstract.h:523

libMesh::FEGenericBase< FEOutputType< T >::type >::d2phidxidzeta

libmesh_assert(j)

std::vector< std::vector< OutputShape > > d2phidxidzeta

Definition: fe_base.h:567

bool calculate_dphiref

Definition: fe_abstract.h:553

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidy2 ( ) const

inlineinherited

Returns: The shape function second derivatives at the quadrature points.

Definition at line 322 of file fe_base.h.

References libMesh::FEAbstract::calculate_d2phi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< OutputType >::d2phidy2, and libMesh::libmesh_assert().

323 { libmesh_assert(!calculations_started || calculate_d2phi);

324 calculate_d2phi = calculate_dphiref = true; return d2phidy2; }

bool calculate_d2phi

Definition: fe_abstract.h:538

libMesh::FEGenericBase< FEOutputType< T >::type >::d2phidy2

bool calculations_started

Definition: fe_abstract.h:523

std::vector< std::vector< OutputShape > > d2phidy2

Definition: fe_base.h:602

libmesh_assert(j)

bool calculate_dphiref

Definition: fe_abstract.h:553

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidydz ( ) const

inlineinherited

Returns: The shape function second derivatives at the quadrature points.

Definition at line 330 of file fe_base.h.

References libMesh::FEAbstract::calculate_d2phi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< OutputType >::d2phidydz, and libMesh::libmesh_assert().

331 { libmesh_assert(!calculations_started || calculate_d2phi);

332 calculate_d2phi = calculate_dphiref = true; return d2phidydz; }

bool calculate_d2phi

Definition: fe_abstract.h:538

libMesh::FEGenericBase< FEOutputType< T >::type >::d2phidydz

bool calculations_started

Definition: fe_abstract.h:523

std::vector< std::vector< OutputShape > > d2phidydz

Definition: fe_base.h:607

libmesh_assert(j)

bool calculate_dphiref

Definition: fe_abstract.h:553

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidz2 ( ) const

inlineinherited

Returns: The shape function second derivatives at the quadrature points.

Definition at line 338 of file fe_base.h.

References libMesh::FEAbstract::calculate_d2phi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< OutputType >::d2phidz2, and libMesh::libmesh_assert().

339 { libmesh_assert(!calculations_started || calculate_d2phi);

340 calculate_d2phi = calculate_dphiref = true; return d2phidz2; }

bool calculate_d2phi

Definition: fe_abstract.h:538

bool calculations_started

Definition: fe_abstract.h:523

libmesh_assert(j)

libMesh::FEGenericBase< FEOutputType< T >::type >::d2phidz2

bool calculate_dphiref

Definition: fe_abstract.h:553

std::vector< std::vector< OutputShape > > d2phidz2

Definition: fe_base.h:612

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_d2phidzeta2 ( ) const

inlineinherited

Returns: The shape function second derivatives at the quadrature points, in reference coordinates

Definition at line 386 of file fe_base.h.

References libMesh::FEAbstract::calculate_d2phi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< OutputType >::d2phidzeta2, and libMesh::libmesh_assert().

387 { libmesh_assert(!calculations_started || calculate_d2phi);

388 calculate_d2phi = calculate_dphiref = true; return d2phidzeta2; }

bool calculate_d2phi

Definition: fe_abstract.h:538

bool calculations_started

Definition: fe_abstract.h:523

libmesh_assert(j)

libMesh::FEGenericBase< FEOutputType< T >::type >::d2phidzeta2

bool calculate_dphiref

Definition: fe_abstract.h:553

std::vector< std::vector< OutputShape > > d2phidzeta2

Definition: fe_base.h:582

const std::vector<RealGradient>& libMesh::FEAbstract::get_d2xyzdeta2 ( ) const

inlineinherited

Returns: The second partial derivatives in eta.

Definition at line 264 of file fe_abstract.h.

265 { return this->_fe_map->get_d2xyzdeta2(); }

UniquePtr< FEMap > _fe_map

Definition: fe_abstract.h:511

const std::vector<RealGradient>& libMesh::FEAbstract::get_d2xyzdetadzeta ( ) const

inlineinherited

Returns: The second partial derivatives in eta-zeta.

Definition at line 294 of file fe_abstract.h.

295 { return this->_fe_map->get_d2xyzdetadzeta(); }

UniquePtr< FEMap > _fe_map

Definition: fe_abstract.h:511

const std::vector<RealGradient>& libMesh::FEAbstract::get_d2xyzdxi2 ( ) const

inlineinherited

Returns: The second partial derivatives in xi.

Definition at line 258 of file fe_abstract.h.

259 { return this->_fe_map->get_d2xyzdxi2(); }

UniquePtr< FEMap > _fe_map

Definition: fe_abstract.h:511

const std::vector<RealGradient>& libMesh::FEAbstract::get_d2xyzdxideta ( ) const

inlineinherited

Returns: The second partial derivatives in xi-eta.

Definition at line 280 of file fe_abstract.h.

281 { return this->_fe_map->get_d2xyzdxideta(); }

UniquePtr< FEMap > _fe_map

Definition: fe_abstract.h:511

const std::vector<RealGradient>& libMesh::FEAbstract::get_d2xyzdxidzeta ( ) const

inlineinherited

Returns: The second partial derivatives in xi-zeta.

Definition at line 288 of file fe_abstract.h.

289 { return this->_fe_map->get_d2xyzdxidzeta(); }

UniquePtr< FEMap > _fe_map

Definition: fe_abstract.h:511

const std::vector<RealGradient>& libMesh::FEAbstract::get_d2xyzdzeta2 ( ) const

inlineinherited

Returns: The second partial derivatives in zeta.

Definition at line 272 of file fe_abstract.h.

273 { return this->_fe_map->get_d2xyzdzeta2(); }

UniquePtr< FEMap > _fe_map

Definition: fe_abstract.h:511

const std::vector<Real>& libMesh::FEAbstract::get_detadx ( ) const

inlineinherited

Returns: The deta/dx entry in the transformation matrix from physical to local coordinates.

Definition at line 324 of file fe_abstract.h.

325 { return this->_fe_map->get_detadx(); }

UniquePtr< FEMap > _fe_map

Definition: fe_abstract.h:511

const std::vector<Real>& libMesh::FEAbstract::get_detady ( ) const

inlineinherited

Returns: The deta/dy entry in the transformation matrix from physical to local coordinates.

Definition at line 331 of file fe_abstract.h.

332 { return this->_fe_map->get_detady(); }

UniquePtr< FEMap > _fe_map

Definition: fe_abstract.h:511

const std::vector<Real>& libMesh::FEAbstract::get_detadz ( ) const

inlineinherited

Returns: The deta/dz entry in the transformation matrix from physical to local coordinates.

Definition at line 338 of file fe_abstract.h.

339 { return this->_fe_map->get_detadz(); }

UniquePtr< FEMap > _fe_map

Definition: fe_abstract.h:511

const std::vector<std::vector<OutputDivergence> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_div_phi ( ) const

inlineinherited

Returns: The divergence of the shape function at the quadrature points.

Definition at line 232 of file fe_base.h.

References libMesh::FEAbstract::calculate_div_phi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< OutputType >::div_phi, and libMesh::libmesh_assert().

233 { libmesh_assert(!calculations_started || calculate_div_phi);

234 calculate_div_phi = calculate_dphiref = true; return div_phi; }

libMesh::FEAbstract::calculate_div_phi

bool calculations_started

Definition: fe_abstract.h:523

bool calculate_div_phi

Definition: fe_abstract.h:548

libMesh::FEGenericBase< FEOutputType< T >::type >::div_phi

libmesh_assert(j)

std::vector< std::vector< OutputDivergence > > div_phi

Definition: fe_base.h:514

libMesh::FEGenericBase< FEOutputType< T >::type >::dphase

bool calculate_dphiref

Definition: fe_abstract.h:553

const std::vector<OutputGradient>& libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphase ( ) const

inlineinherited

Returns: The global first derivative of the phase term which is used in infinite elements, evaluated at the quadrature points.

In case of the general finite element class FE this field is initialized to all zero, so that the variational formulation for an infinite element produces correct element matrices for a mesh using both finite and infinite elements.

Definition at line 404 of file fe_base.h.

References libMesh::FEGenericBase< OutputType >::dphase.

405 { return dphase; }

std::vector< OutputGradient > dphase

Definition: fe_base.h:630

const std::vector<std::vector<OutputGradient> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphi ( ) const

inlineinherited

Returns: The shape function derivatives at the quadrature points.

Definition at line 216 of file fe_base.h.

References libMesh::FEAbstract::calculate_dphi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< OutputType >::dphi, and libMesh::libmesh_assert().

217 { libmesh_assert(!calculations_started || calculate_dphi);

218 calculate_dphi = calculate_dphiref = true; return dphi; }

bool calculations_started

Definition: fe_abstract.h:523

libmesh_assert(j)

libMesh::FEGenericBase< FEOutputType< T >::type >::dphi

bool calculate_dphiref

Definition: fe_abstract.h:553

std::vector< std::vector< OutputGradient > > dphi

Definition: fe_base.h:504

bool calculate_dphi

Definition: fe_abstract.h:533

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphideta ( ) const

inlineinherited

Returns: The shape function eta-derivative at the quadrature points.

Definition at line 272 of file fe_base.h.

References libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< OutputType >::dphideta, and libMesh::libmesh_assert().

273 { libmesh_assert(!calculations_started || calculate_dphiref);

274 calculate_dphiref = true; return dphideta; }

bool calculations_started

Definition: fe_abstract.h:523

libmesh_assert(j)

libMesh::FEGenericBase< FEOutputType< T >::type >::dphideta

bool calculate_dphiref

Definition: fe_abstract.h:553

std::vector< std::vector< OutputShape > > dphideta

Definition: fe_base.h:524

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphidx ( ) const

inlineinherited

Returns: The shape function x-derivative at the quadrature points.

Definition at line 240 of file fe_base.h.

References libMesh::FEAbstract::calculate_dphi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< OutputType >::dphidx, and libMesh::libmesh_assert().

241 { libmesh_assert(!calculations_started || calculate_dphi);

242 calculate_dphi = calculate_dphiref = true; return dphidx; }

bool calculations_started

Definition: fe_abstract.h:523

libMesh::FEGenericBase< FEOutputType< T >::type >::dphidx

libmesh_assert(j)

std::vector< std::vector< OutputShape > > dphidx

Definition: fe_base.h:534

bool calculate_dphiref

Definition: fe_abstract.h:553

libMesh::FEGenericBase< FEOutputType< T >::type >::dphidxi

bool calculate_dphi

Definition: fe_abstract.h:533

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphidxi ( ) const

inlineinherited

Returns: The shape function xi-derivative at the quadrature points.

Definition at line 264 of file fe_base.h.

References libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< OutputType >::dphidxi, and libMesh::libmesh_assert().

265 { libmesh_assert(!calculations_started || calculate_dphiref);

266 calculate_dphiref = true; return dphidxi; }

std::vector< std::vector< OutputShape > > dphidxi

Definition: fe_base.h:519

bool calculations_started

Definition: fe_abstract.h:523

libmesh_assert(j)

bool calculate_dphiref

Definition: fe_abstract.h:553

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphidy ( ) const

inlineinherited

Returns: The shape function y-derivative at the quadrature points.

Definition at line 248 of file fe_base.h.

References libMesh::FEAbstract::calculate_dphi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< OutputType >::dphidy, and libMesh::libmesh_assert().

249 { libmesh_assert(!calculations_started || calculate_dphi);

250 calculate_dphi = calculate_dphiref = true; return dphidy; }

libMesh::FEGenericBase< FEOutputType< T >::type >::dphidy

bool calculations_started

Definition: fe_abstract.h:523

std::vector< std::vector< OutputShape > > dphidy

Definition: fe_base.h:539

libmesh_assert(j)

bool calculate_dphiref

Definition: fe_abstract.h:553

bool calculate_dphi

Definition: fe_abstract.h:533

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphidz ( ) const

inlineinherited

Returns: The shape function z-derivative at the quadrature points.

Definition at line 256 of file fe_base.h.

References libMesh::FEAbstract::calculate_dphi, libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< OutputType >::dphidz, and libMesh::libmesh_assert().

257 { libmesh_assert(!calculations_started || calculate_dphi);

258 calculate_dphi = calculate_dphiref = true; return dphidz; }

bool calculations_started

Definition: fe_abstract.h:523

libmesh_assert(j)

bool calculate_dphiref

Definition: fe_abstract.h:553

libMesh::FEGenericBase< FEOutputType< T >::type >::dphidz

bool calculate_dphi

Definition: fe_abstract.h:533

std::vector< std::vector< OutputShape > > dphidz

Definition: fe_base.h:544

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_dphidzeta ( ) const

inlineinherited

Returns: The shape function zeta-derivative at the quadrature points.

Definition at line 280 of file fe_base.h.

References libMesh::FEAbstract::calculate_dphiref, libMesh::FEAbstract::calculations_started, libMesh::FEGenericBase< OutputType >::dphidzeta, and libMesh::libmesh_assert().

281 { libmesh_assert(!calculations_started || calculate_dphiref);

282 calculate_dphiref = true; return dphidzeta; }

libMesh::FEGenericBase< FEOutputType< T >::type >::dphidzeta

std::vector< std::vector< OutputShape > > dphidzeta

Definition: fe_base.h:529

bool calculations_started

Definition: fe_abstract.h:523

libmesh_assert(j)

bool calculate_dphiref

Definition: fe_abstract.h:553

const std::vector<Real>& libMesh::FEAbstract::get_dxidx ( ) const

inlineinherited

Returns: The dxi/dx entry in the transformation matrix from physical to local coordinates.

Definition at line 303 of file fe_abstract.h.

304 { return this->_fe_map->get_dxidx(); }

UniquePtr< FEMap > _fe_map

Definition: fe_abstract.h:511

const std::vector<Real>& libMesh::FEAbstract::get_dxidy ( ) const

inlineinherited

Returns: The dxi/dy entry in the transformation matrix from physical to local coordinates.

Definition at line 310 of file fe_abstract.h.

311 { return this->_fe_map->get_dxidy(); }

UniquePtr< FEMap > _fe_map

Definition: fe_abstract.h:511

const std::vector<Real>& libMesh::FEAbstract::get_dxidz ( ) const

inlineinherited

Returns: The dxi/dz entry in the transformation matrix from physical to local coordinates.

Definition at line 317 of file fe_abstract.h.

318 { return this->_fe_map->get_dxidz(); }

UniquePtr< FEMap > _fe_map

Definition: fe_abstract.h:511

const std::vector<RealGradient>& libMesh::FEAbstract::get_dxyzdeta ( ) const

inlineinherited

Returns: The element tangents in eta-direction at the quadrature points.

Definition at line 245 of file fe_abstract.h.

246 { return this->_fe_map->get_dxyzdeta(); }

UniquePtr< FEMap > _fe_map

Definition: fe_abstract.h:511

const std::vector<RealGradient>& libMesh::FEAbstract::get_dxyzdxi ( ) const

inlineinherited

Returns: The element tangents in xi-direction at the quadrature points.

Definition at line 238 of file fe_abstract.h.

239 { return this->_fe_map->get_dxyzdxi(); }

UniquePtr< FEMap > _fe_map

Definition: fe_abstract.h:511

const std::vector<RealGradient>& libMesh::FEAbstract::get_dxyzdzeta ( ) const

inlineinherited

Returns: The element tangents in zeta-direction at the quadrature points.

Definition at line 252 of file fe_abstract.h.

253 { return _fe_map->get_dxyzdzeta(); }

UniquePtr< FEMap > _fe_map

Definition: fe_abstract.h:511

const std::vector<Real>& libMesh::FEAbstract::get_dzetadx ( ) const

inlineinherited

Returns: The dzeta/dx entry in the transformation matrix from physical to local coordinates.

Definition at line 345 of file fe_abstract.h.

346 { return this->_fe_map->get_dzetadx(); }

UniquePtr< FEMap > _fe_map

Definition: fe_abstract.h:511

const std::vector<Real>& libMesh::FEAbstract::get_dzetady ( ) const

inlineinherited

Returns: The dzeta/dy entry in the transformation matrix from physical to local coordinates.

Definition at line 352 of file fe_abstract.h.

353 { return this->_fe_map->get_dzetady(); }

UniquePtr< FEMap > _fe_map

Definition: fe_abstract.h:511

const std::vector<Real>& libMesh::FEAbstract::get_dzetadz ( ) const

inlineinherited

Returns: The dzeta/dz entry in the transformation matrix from physical to local coordinates.

Definition at line 359 of file fe_abstract.h.

360 { return this->_fe_map->get_dzetadz(); }

UniquePtr< FEMap > _fe_map

Definition: fe_abstract.h:511

FEFamily libMesh::FEAbstract::get_family ( ) const

inlineinherited

Returns: The finite element family of this element.

Definition at line 441 of file fe_abstract.h.

References libMesh::FEType::family, and libMesh::FEAbstract::fe_type.

Referenced by libMesh::FE< Dim, T >::FE().

441 { return fe_type.family; }

libMesh::FEType::family

FEFamily family

Definition: fe_type.h:203

References libMesh::FEAbstract::_fe_map, libMesh::FEAbstract::compute_shape_functions(), libMesh::FEAbstract::operator<<, libMesh::FEAbstract::print_d2phi(), libMesh::FEAbstract::print_dphi(), libMesh::FEAbstract::print_info(), libMesh::FEAbstract::print_JxW(), libMesh::FEAbstract::print_phi(), and libMesh::FEAbstract::print_xyz().

FEType fe_type

Definition: fe_abstract.h:561

const FEMap& libMesh::FEAbstract::get_fe_map ( ) const

inlineinherited

Returns: The mapping object

Definition at line 446 of file fe_abstract.h.

446 { return *_fe_map.get(); }

Referenced by libMesh::FEMContext::build_new_fe(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::H1FETransformation< OutputShape >::map_phi(), libMesh::HCurlFETransformation< OutputShape >::map_phi(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::operator()(), and libMesh::JumpErrorEstimator::reinit_sides().

UniquePtr< FEMap > _fe_map

Definition: fe_abstract.h:511

FEType libMesh::FEAbstract::get_fe_type ( ) const

inlineinherited

Returns: The FE Type (approximation order and family) of the finite element.

Definition at line 415 of file fe_abstract.h.

References libMesh::FEAbstract::fe_type.

415 { return fe_type; }

FEType fe_type

Definition: fe_abstract.h:561

std::string libMesh::ReferenceCounter::get_info ( )

staticinherited

Gets a string containing the reference information.

Definition at line 47 of file reference_counter.C.

References libMesh::ReferenceCounter::_counts, and libMesh::Quality::name().

Referenced by libMesh::ReferenceCounter::print_info().

 {
 #if defined(LIBMESH_ENABLE_REFERENCE_COUNTING) && defined(DEBUG)
 
   std::ostringstream oss;
 
   oss << '\n'
       << " ---------------------------------------------------------------------------- \n"
       << "| Reference count information                                                |\n"
       << " ---------------------------------------------------------------------------- \n";
 
   for (Counts::iterator it = _counts.begin();
        it != _counts.end(); ++it)
     {
       const std::string name(it->first);
       const unsigned int creations    = it->second.first;
       const unsigned int destructions = it->second.second;
 
       oss << "| " << name << " reference count information:\n"
           << "|  Creations:    " << creations    << '\n'
           << "|  Destructions: " << destructions << '\n';
     }
 
   oss << " ---------------------------------------------------------------------------- \n";
 
   return oss.str();
 
 #else
 
   return "";
 
 #endif
 }

const std::vector<Real>& libMesh::FEAbstract::get_JxW ( ) const

inlineinherited

Returns: The element Jacobian times the quadrature weight for each quadrature point.

Definition at line 231 of file fe_abstract.h.

Referenced by libMesh::ExactSolution::_compute_error(), libMesh::DiscontinuityMeasure::boundary_side_integration(), libMesh::KellyErrorEstimator::boundary_side_integration(), libMesh::System::calculate_norm(), libMesh::ExactErrorEstimator::find_squared_element_error(), libMesh::FEMSystem::init_context(), libMesh::LaplacianErrorEstimator::internal_side_integration(), libMesh::DiscontinuityMeasure::internal_side_integration(), libMesh::KellyErrorEstimator::internal_side_integration(), and libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::operator()().

232 { return this->_fe_map->get_JxW(); }

UniquePtr< FEMap > _fe_map

Definition: fe_abstract.h:511

const std::vector<Point>& libMesh::FEAbstract::get_normals ( ) const

inlineinherited

Returns: The outward pointing normal vectors for face integration.

Definition at line 371 of file fe_abstract.h.

Referenced by libMesh::KellyErrorEstimator::boundary_side_integration(), libMesh::ParsedFEMFunction< Output >::eval_args(), libMesh::ParsedFEMFunction< Output >::init_context(), libMesh::KellyErrorEstimator::init_context(), and libMesh::KellyErrorEstimator::internal_side_integration().

372 { return this->_fe_map->get_normals(); }

libMesh::FEAbstract::_p_level

UniquePtr< FEMap > _fe_map

Definition: fe_abstract.h:511

Order libMesh::FEAbstract::get_order ( ) const

inlineinherited

Returns: The approximation order of the finite element.

Definition at line 420 of file fe_abstract.h.

References libMesh::FEAbstract::_p_level, libMesh::FEAbstract::fe_type, and libMesh::FEType::order.

420 { return static_cast<Order>(fe_type.order + _p_level); }

unsigned int _p_level

Definition: fe_abstract.h:573

libMesh::FEType::order

OrderWrapper order

Definition: fe_type.h:197

libMesh::Order

Order

Definition: enum_order.h:32

libMesh::FEAbstract::_p_level

FEType fe_type

Definition: fe_abstract.h:561

unsigned int libMesh::FEAbstract::get_p_level ( ) const

inlineinherited

Returns: The p refinement level that the current shape functions have been calculated for.

Definition at line 410 of file fe_abstract.h.

References libMesh::FEAbstract::_p_level.

410 { return _p_level; }

unsigned int _p_level

Definition: fe_abstract.h:573

const std::vector<std::vector<OutputShape> >& libMesh::FEGenericBase< FEOutputType< T >::type >::get_phi ( ) const

inlineinherited

Returns: The shape function values at the quadrature points on the element.

Definition at line 208 of file fe_base.h.

References libMesh::FEAbstract::calculate_phi, libMesh::FEAbstract::calculations_started, libMesh::libmesh_assert(), and libMesh::FEGenericBase< OutputType >::phi.

209 { libmesh_assert(!calculations_started || calculate_phi);

210 calculate_phi = true; return phi; }

libMesh::FEAbstract::calculate_phi

bool calculations_started

Definition: fe_abstract.h:523

bool calculate_phi

Definition: fe_abstract.h:528

libMesh::FEGenericBase< FEOutputType< T >::type >::phi

libmesh_assert(j)

std::vector< std::vector< OutputShape > > phi

Definition: fe_base.h:499

void libMesh::FEAbstract::get_refspace_nodes	(	const ElemType	t,
		std::vector< Point > &	nodes
	)

staticinherited

Returns: The reference space coordinates of nodes based on the element type.

Definition at line 259 of file fe_abstract.C.

References libMesh::EDGE2, libMesh::EDGE3, libMesh::HEX20, libMesh::HEX27, libMesh::HEX8, libMesh::PRISM15, libMesh::PRISM18, libMesh::PRISM6, libMesh::PYRAMID13, libMesh::PYRAMID14, libMesh::PYRAMID5, libMesh::QUAD4, libMesh::QUAD8, libMesh::QUAD9, libMesh::QUADSHELL4, libMesh::TET10, libMesh::TET4, libMesh::TRI3, libMesh::TRI6, and libMesh::TRISHELL3.

 {
   switch(itemType)
     {
     case EDGE2:
       {
         nodes.resize(2);
         nodes[0] = Point (-1.,0.,0.);
         nodes[1] = Point (1.,0.,0.);
         return;
       }
     case EDGE3:
       {
         nodes.resize(3);
         nodes[0] = Point (-1.,0.,0.);
         nodes[1] = Point (1.,0.,0.);
         nodes[2] = Point (0.,0.,0.);
         return;
       }
     case TRI3:
     case TRISHELL3:
       {
         nodes.resize(3);
         nodes[0] = Point (0.,0.,0.);
         nodes[1] = Point (1.,0.,0.);
         nodes[2] = Point (0.,1.,0.);
         return;
       }
     case TRI6:
       {
         nodes.resize(6);
         nodes[0] = Point (0.,0.,0.);
         nodes[1] = Point (1.,0.,0.);
         nodes[2] = Point (0.,1.,0.);
         nodes[3] = Point (.5,0.,0.);
         nodes[4] = Point (.5,.5,0.);
         nodes[5] = Point (0.,.5,0.);
         return;
       }
     case QUAD4:
     case QUADSHELL4:
       {
         nodes.resize(4);
         nodes[0] = Point (-1.,-1.,0.);
         nodes[1] = Point (1.,-1.,0.);
         nodes[2] = Point (1.,1.,0.);
         nodes[3] = Point (-1.,1.,0.);
         return;
       }
     case QUAD8:
       {
         nodes.resize(8);
         nodes[0] = Point (-1.,-1.,0.);
         nodes[1] = Point (1.,-1.,0.);
         nodes[2] = Point (1.,1.,0.);
         nodes[3] = Point (-1.,1.,0.);
         nodes[4] = Point (0.,-1.,0.);
         nodes[5] = Point (1.,0.,0.);
         nodes[6] = Point (0.,1.,0.);
         nodes[7] = Point (-1.,0.,0.);
         return;
       }
     case QUAD9:
       {
         nodes.resize(9);
         nodes[0] = Point (-1.,-1.,0.);
         nodes[1] = Point (1.,-1.,0.);
         nodes[2] = Point (1.,1.,0.);
         nodes[3] = Point (-1.,1.,0.);
         nodes[4] = Point (0.,-1.,0.);
         nodes[5] = Point (1.,0.,0.);
         nodes[6] = Point (0.,1.,0.);
         nodes[7] = Point (-1.,0.,0.);
         nodes[8] = Point (0.,0.,0.);
         return;
       }
     case TET4:
       {
         nodes.resize(4);
         nodes[0] = Point (0.,0.,0.);
         nodes[1] = Point (1.,0.,0.);
         nodes[2] = Point (0.,1.,0.);
         nodes[3] = Point (0.,0.,1.);
         return;
       }
     case TET10:
       {
         nodes.resize(10);
         nodes[0] = Point (0.,0.,0.);
         nodes[1] = Point (1.,0.,0.);
         nodes[2] = Point (0.,1.,0.);
         nodes[3] = Point (0.,0.,1.);
         nodes[4] = Point (.5,0.,0.);
         nodes[5] = Point (.5,.5,0.);
         nodes[6] = Point (0.,.5,0.);
         nodes[7] = Point (0.,0.,.5);
         nodes[8] = Point (.5,0.,.5);
         nodes[9] = Point (0.,.5,.5);
         return;
       }
     case HEX8:
       {
         nodes.resize(8);
         nodes[0] = Point (-1.,-1.,-1.);
         nodes[1] = Point (1.,-1.,-1.);
         nodes[2] = Point (1.,1.,-1.);
         nodes[3] = Point (-1.,1.,-1.);
         nodes[4] = Point (-1.,-1.,1.);
         nodes[5] = Point (1.,-1.,1.);
         nodes[6] = Point (1.,1.,1.);
         nodes[7] = Point (-1.,1.,1.);
         return;
       }
     case HEX20:
       {
         nodes.resize(20);
         nodes[0] = Point (-1.,-1.,-1.);
         nodes[1] = Point (1.,-1.,-1.);
         nodes[2] = Point (1.,1.,-1.);
         nodes[3] = Point (-1.,1.,-1.);
         nodes[4] = Point (-1.,-1.,1.);
         nodes[5] = Point (1.,-1.,1.);
         nodes[6] = Point (1.,1.,1.);
         nodes[7] = Point (-1.,1.,1.);
         nodes[8] = Point (0.,-1.,-1.);
         nodes[9] = Point (1.,0.,-1.);
         nodes[10] = Point (0.,1.,-1.);
         nodes[11] = Point (-1.,0.,-1.);
         nodes[12] = Point (-1.,-1.,0.);
         nodes[13] = Point (1.,-1.,0.);
         nodes[14] = Point (1.,1.,0.);
         nodes[15] = Point (-1.,1.,0.);
         nodes[16] = Point (0.,-1.,1.);
         nodes[17] = Point (1.,0.,1.);
         nodes[18] = Point (0.,1.,1.);
         nodes[19] = Point (-1.,0.,1.);
         return;
       }
     case HEX27:
       {
         nodes.resize(27);
         nodes[0] = Point (-1.,-1.,-1.);
         nodes[1] = Point (1.,-1.,-1.);
         nodes[2] = Point (1.,1.,-1.);
         nodes[3] = Point (-1.,1.,-1.);
         nodes[4] = Point (-1.,-1.,1.);
         nodes[5] = Point (1.,-1.,1.);
         nodes[6] = Point (1.,1.,1.);
         nodes[7] = Point (-1.,1.,1.);
         nodes[8] = Point (0.,-1.,-1.);
         nodes[9] = Point (1.,0.,-1.);
         nodes[10] = Point (0.,1.,-1.);
         nodes[11] = Point (-1.,0.,-1.);
         nodes[12] = Point (-1.,-1.,0.);
         nodes[13] = Point (1.,-1.,0.);
         nodes[14] = Point (1.,1.,0.);
         nodes[15] = Point (-1.,1.,0.);
         nodes[16] = Point (0.,-1.,1.);
         nodes[17] = Point (1.,0.,1.);
         nodes[18] = Point (0.,1.,1.);
         nodes[19] = Point (-1.,0.,1.);
         nodes[20] = Point (0.,0.,-1.);
         nodes[21] = Point (0.,-1.,0.);
         nodes[22] = Point (1.,0.,0.);
         nodes[23] = Point (0.,1.,0.);
         nodes[24] = Point (-1.,0.,0.);
         nodes[25] = Point (0.,0.,1.);
         nodes[26] = Point (0.,0.,0.);
         return;
       }
     case PRISM6:
       {
         nodes.resize(6);
         nodes[0] = Point (0.,0.,-1.);
         nodes[1] = Point (1.,0.,-1.);
         nodes[2] = Point (0.,1.,-1.);
         nodes[3] = Point (0.,0.,1.);
         nodes[4] = Point (1.,0.,1.);
         nodes[5] = Point (0.,1.,1.);
         return;
       }
     case PRISM15:
       {
         nodes.resize(15);
         nodes[0] = Point (0.,0.,-1.);
         nodes[1] = Point (1.,0.,-1.);
         nodes[2] = Point (0.,1.,-1.);
         nodes[3] = Point (0.,0.,1.);
         nodes[4] = Point (1.,0.,1.);
         nodes[5] = Point (0.,1.,1.);
         nodes[6] = Point (.5,0.,-1.);
         nodes[7] = Point (.5,.5,-1.);
         nodes[8] = Point (0.,.5,-1.);
         nodes[9] = Point (0.,0.,0.);
         nodes[10] = Point (1.,0.,0.);
         nodes[11] = Point (0.,1.,0.);
         nodes[12] = Point (.5,0.,1.);
         nodes[13] = Point (.5,.5,1.);
         nodes[14] = Point (0.,.5,1.);
         return;
       }
     case PRISM18:
       {
         nodes.resize(18);
         nodes[0] = Point (0.,0.,-1.);
         nodes[1] = Point (1.,0.,-1.);
         nodes[2] = Point (0.,1.,-1.);
         nodes[3] = Point (0.,0.,1.);
         nodes[4] = Point (1.,0.,1.);
         nodes[5] = Point (0.,1.,1.);
         nodes[6] = Point (.5,0.,-1.);
         nodes[7] = Point (.5,.5,-1.);
         nodes[8] = Point (0.,.5,-1.);
         nodes[9] = Point (0.,0.,0.);
         nodes[10] = Point (1.,0.,0.);
         nodes[11] = Point (0.,1.,0.);
         nodes[12] = Point (.5,0.,1.);
         nodes[13] = Point (.5,.5,1.);
         nodes[14] = Point (0.,.5,1.);
         nodes[15] = Point (.5,0.,0.);
         nodes[16] = Point (.5,.5,0.);
         nodes[17] = Point (0.,.5,0.);
         return;
       }
     case PYRAMID5:
       {
         nodes.resize(5);
         nodes[0] = Point (-1.,-1.,0.);
         nodes[1] = Point (1.,-1.,0.);
         nodes[2] = Point (1.,1.,0.);
         nodes[3] = Point (-1.,1.,0.);
         nodes[4] = Point (0.,0.,1.);
         return;
       }
     case PYRAMID13:
       {
         nodes.resize(13);
 
         // base corners
         nodes[0] = Point (-1.,-1.,0.);
         nodes[1] = Point (1.,-1.,0.);
         nodes[2] = Point (1.,1.,0.);
         nodes[3] = Point (-1.,1.,0.);
 
         // apex
         nodes[4] = Point (0.,0.,1.);
 
         // base midedge
         nodes[5] = Point (0.,-1.,0.);
         nodes[6] = Point (1.,0.,0.);
         nodes[7] = Point (0.,1.,0.);
         nodes[8] = Point (-1,0.,0.);
 
         // lateral midedge
         nodes[9] = Point (-.5,-.5,.5);
         nodes[10] = Point (.5,-.5,.5);
         nodes[11] = Point (.5,.5,.5);
         nodes[12] = Point (-.5,.5,.5);
 
         return;
       }
     case PYRAMID14:
       {
         nodes.resize(14);
 
         // base corners
         nodes[0] = Point (-1.,-1.,0.);
         nodes[1] = Point (1.,-1.,0.);
         nodes[2] = Point (1.,1.,0.);
         nodes[3] = Point (-1.,1.,0.);
 
         // apex
         nodes[4] = Point (0.,0.,1.);
 
         // base midedge
         nodes[5] = Point (0.,-1.,0.);
         nodes[6] = Point (1.,0.,0.);
         nodes[7] = Point (0.,1.,0.);
         nodes[8] = Point (-1,0.,0.);
 
         // lateral midedge
         nodes[9] = Point (-.5,-.5,.5);
         nodes[10] = Point (.5,-.5,.5);
         nodes[11] = Point (.5,.5,.5);
         nodes[12] = Point (-.5,.5,.5);
 
         // base center
         nodes[13] = Point (0.,0.,0.);
 
         return;
       }
 
     default:
       libmesh_error_msg("ERROR: Unknown element type " << itemType);
     }
 }

const std::vector<RealGradient>& libMesh::FEGenericBase< FEOutputType< T >::type >::get_Sobolev_dweight ( ) const

inlineinherited

Returns: The first global derivative of the multiplicative weight at each quadrature point. See get_Sobolev_weight() for details. In case of FE initialized to all zero.

Definition at line 428 of file fe_base.h.

References libMesh::FEGenericBase< OutputType >::compute_shape_functions(), libMesh::FEGenericBase< OutputType >::determine_calculations(), libMesh::FEGenericBase< OutputType >::dweight, libMesh::FEGenericBase< OutputType >::init_base_shape_functions(), libMesh::FEGenericBase< OutputType >::print_d2phi(), libMesh::FEGenericBase< OutputType >::print_dphi(), and libMesh::FEGenericBase< OutputType >::print_phi().

429 { return dweight; }

libMesh::FEGenericBase< FEOutputType< T >::type >::dweight

std::vector< RealGradient > dweight

Definition: fe_base.h:637

const std::vector<Real>& libMesh::FEGenericBase< FEOutputType< T >::type >::get_Sobolev_weight ( ) const

inlineinherited

Returns: The multiplicative weight at each quadrature point. This weight is used for certain infinite element weak formulations, so that weighted Sobolev spaces are used for the trial function space. This renders the variational form easily computable.

In case of the general finite element class FE this field is initialized to all ones, so that the variational formulation for an infinite element produces correct element matrices for a mesh using both finite and infinite elements.

Definition at line 420 of file fe_base.h.

References libMesh::FEGenericBase< OutputType >::weight.

421 { return weight; }

libMesh::FEGenericBase< FEOutputType< T >::type >::weight

std::vector< Real > weight

Definition: fe_base.h:644

const std::vector<std::vector<Point> >& libMesh::FEAbstract::get_tangents ( ) const

inlineinherited

Returns: The tangent vectors for face integration.

Definition at line 365 of file fe_abstract.h.

366 { return this->_fe_map->get_tangents(); }

libMesh::FEAbstract::elem_type

UniquePtr< FEMap > _fe_map

Definition: fe_abstract.h:511

ElemType libMesh::FEAbstract::get_type ( ) const

inlineinherited

Returns: The element type that the current shape functions have been calculated for. Useful in determining when shape functions must be recomputed.

Definition at line 404 of file fe_abstract.h.

References libMesh::FEAbstract::elem_type.

Referenced by libMesh::InfFE< Dim, T_radial, T_map >::reinit().

404 { return elem_type; }

ElemType elem_type

Definition: fe_abstract.h:567

const std::vector<Point>& libMesh::FEAbstract::get_xyz ( ) const

inlineinherited

Returns: The xyz spatial locations of the quadrature points on the element.

Definition at line 224 of file fe_abstract.h.

Referenced by libMesh::ExactSolution::_compute_error(), libMesh::DiscontinuityMeasure::boundary_side_integration(), libMesh::KellyErrorEstimator::boundary_side_integration(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::ParsedFEMFunction< Output >::eval_args(), libMesh::ExactErrorEstimator::find_squared_element_error(), libMesh::ParsedFEMFunction< Output >::init_context(), libMesh::DGFEMContext::neighbor_side_fe_reinit(), libMesh::GenericProjector< FFunctor, GFunctor, FValue, ProjectionAction >::operator()(), and libMesh::InfFE< Dim, T_radial, T_map >::reinit().

225 { return this->_fe_map->get_xyz(); }

UniquePtr< FEMap > _fe_map

Definition: fe_abstract.h:511

void libMesh::ReferenceCounter::increment_constructor_count ( const std::string & name )

inlineprotectedinherited

Increments the construction counter. Should be called in the constructor of any derived class that will be reference counted.

Definition at line 185 of file reference_counter.h.

References libMesh::ReferenceCounter::_counts, libMesh::Quality::name(), and libMesh::Threads::spin_mtx.

Referenced by libMesh::ReferenceCounter::n_objects(), and libMesh::ReferenceCountedObject< RBParametrized >::ReferenceCountedObject().

 {
   Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
   std::pair<unsigned int, unsigned int> & p = _counts[name];
 
   p.first++;
 }

void libMesh::ReferenceCounter::increment_destructor_count ( const std::string & name )

inlineprotectedinherited

Increments the destruction counter. Should be called in the destructor of any derived class that will be reference counted.

Definition at line 198 of file reference_counter.h.

References libMesh::ReferenceCounter::_counts, libMesh::Quality::name(), and libMesh::Threads::spin_mtx.

Referenced by libMesh::ReferenceCounter::n_objects(), and libMesh::ReferenceCountedObject< RBParametrized >::~ReferenceCountedObject().

 {
   Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx);
   std::pair<unsigned int, unsigned int> & p = _counts[name];
 
   p.second++;
 }

template<unsigned int Dim, FEFamily T>

void libMesh::FE< Dim, T >::init_base_shape_functions	(	const std::vector< Point > &	qp,
		const Elem *	e
	)

protectedvirtual

Initialize the data fields for the base of an an infinite element.

Implements libMesh::FEGenericBase< FEOutputType< T >::type >.

Definition at line 536 of file fe.C.

References libMesh::INSTANTIATE_FE(), and libMesh::Elem::type().

 {
   this->elem_type = e->type();
   this->_fe_map->template init_reference_to_physical_map<Dim>(qp, e);
   init_shape_functions(qp, e);
 }

template<unsigned int Dim, FEFamily T>

void libMesh::FE< Dim, T >::init_shape_functions	(	const std::vector< Point > &	qp,
		const Elem *	e
	)

protectedvirtual

Update the various member data fields phi, dphidxi, dphideta, dphidzeta, etc. for the current element. These data will be computed at the points qp, which are generally (but need not be) the quadrature points.

Reimplemented in libMesh::FEXYZ< Dim >, and libMesh::FESubdivision.

Definition at line 280 of file fe.C.

References libMesh::FEInterface::field_type(), libMesh::FE< Dim, T >::shape_deriv(), libMesh::FE< Dim, T >::shape_second_deriv(), libMesh::TYPE_VECTOR, and libMesh::MeshTools::weight().

 {
   // Start logging the shape function initialization
   LOG_SCOPE("init_shape_functions()", "FE");
 
   // The number of quadrature points.
   const unsigned int n_qp = cast_int<unsigned int>(qp.size());
 
   // Number of shape functions in the finite element approximation
   // space.
   const unsigned int n_approx_shape_functions =
     this->n_shape_functions(this->get_type(),
                             this->get_order());
 
   // resize the vectors to hold current data
   // Phi are the shape functions used for the FE approximation
   // Phi_map are the shape functions used for the FE mapping
   if (this->calculate_phi)
     this->phi.resize     (n_approx_shape_functions);
 
   if (this->calculate_dphi)
     {
       this->dphi.resize    (n_approx_shape_functions);
       this->dphidx.resize  (n_approx_shape_functions);
       this->dphidy.resize  (n_approx_shape_functions);
       this->dphidz.resize  (n_approx_shape_functions);
     }
 
   if (this->calculate_dphiref)
     {
       if (Dim > 0)
         this->dphidxi.resize (n_approx_shape_functions);
 
       if (Dim > 1)
         this->dphideta.resize      (n_approx_shape_functions);
 
       if (Dim > 2)
         this->dphidzeta.resize     (n_approx_shape_functions);
     }
 
   if (this->calculate_curl_phi && (FEInterface::field_type(T) == TYPE_VECTOR))
     this->curl_phi.resize(n_approx_shape_functions);
 
   if (this->calculate_div_phi && (FEInterface::field_type(T) == TYPE_VECTOR))
     this->div_phi.resize(n_approx_shape_functions);
 
 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
   if (this->calculate_d2phi)
     {
       this->d2phi.resize     (n_approx_shape_functions);
       this->d2phidx2.resize  (n_approx_shape_functions);
       this->d2phidxdy.resize (n_approx_shape_functions);
       this->d2phidxdz.resize (n_approx_shape_functions);
       this->d2phidy2.resize  (n_approx_shape_functions);
       this->d2phidydz.resize (n_approx_shape_functions);
       this->d2phidz2.resize  (n_approx_shape_functions);
 
       if (Dim > 0)
         this->d2phidxi2.resize (n_approx_shape_functions);
 
       if (Dim > 1)
         {
           this->d2phidxideta.resize (n_approx_shape_functions);
           this->d2phideta2.resize   (n_approx_shape_functions);
         }
       if (Dim > 2)
         {
           this->d2phidxidzeta.resize  (n_approx_shape_functions);
           this->d2phidetadzeta.resize (n_approx_shape_functions);
           this->d2phidzeta2.resize    (n_approx_shape_functions);
         }
     }
 #endif // ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
 
   for (unsigned int i=0; i<n_approx_shape_functions; i++)
     {
       if (this->calculate_phi)
         this->phi[i].resize         (n_qp);
       if (this->calculate_dphi)
         {
           this->dphi[i].resize        (n_qp);
           this->dphidx[i].resize      (n_qp);
           this->dphidy[i].resize      (n_qp);
           this->dphidz[i].resize      (n_qp);
         }
 
       if (this->calculate_dphiref)
         {
           if (Dim > 0)
             this->dphidxi[i].resize(n_qp);
 
           if (Dim > 1)
             this->dphideta[i].resize(n_qp);
 
           if (Dim > 2)
             this->dphidzeta[i].resize(n_qp);
         }
 
       if (this->calculate_curl_phi && (FEInterface::field_type(T) == TYPE_VECTOR))
         this->curl_phi[i].resize(n_qp);
 
       if (this->calculate_div_phi && (FEInterface::field_type(T) == TYPE_VECTOR))
         this->div_phi[i].resize(n_qp);
 
 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
       if (this->calculate_d2phi)
         {
           this->d2phi[i].resize     (n_qp);
           this->d2phidx2[i].resize  (n_qp);
           this->d2phidxdy[i].resize (n_qp);
           this->d2phidxdz[i].resize (n_qp);
           this->d2phidy2[i].resize  (n_qp);
           this->d2phidydz[i].resize (n_qp);
           this->d2phidz2[i].resize  (n_qp);
           if (Dim > 0)
             this->d2phidxi2[i].resize (n_qp);
           if (Dim > 1)
             {
               this->d2phidxideta[i].resize (n_qp);
               this->d2phideta2[i].resize   (n_qp);
             }
           if (Dim > 2)
             {
               this->d2phidxidzeta[i].resize  (n_qp);
               this->d2phidetadzeta[i].resize (n_qp);
               this->d2phidzeta2[i].resize    (n_qp);
             }
         }
 #endif // ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
     }
 
 
 #ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
   //------------------------------------------------------------
   // Initialize the data fields, which should only be used for infinite
   // elements, to some sensible values, so that using a FE with the
   // variational formulation of an InfFE, correct element matrices are
   // returned
 
   {
     this->weight.resize  (n_qp);
     this->dweight.resize (n_qp);
     this->dphase.resize  (n_qp);
 
     for (unsigned int p=0; p<n_qp; p++)
       {
         this->weight[p] = 1.;
         this->dweight[p].zero();
         this->dphase[p].zero();
       }
 
   }
 #endif // ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
 
   switch (Dim)
     {
 
       //------------------------------------------------------------
       // 0D
     case 0:
       {
         break;
       }
 
       //------------------------------------------------------------
       // 1D
     case 1:
       {
         // Compute the value of the approximation shape function i at quadrature point p
         if (this->calculate_dphiref)
           for (unsigned int i=0; i<n_approx_shape_functions; i++)
             for (unsigned int p=0; p<n_qp; p++)
               this->dphidxi[i][p]  = FE<Dim,T>::shape_deriv (elem, this->fe_type.order, i, 0, qp[p]);
 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
         if (this->calculate_d2phi)
           for (unsigned int i=0; i<n_approx_shape_functions; i++)
             for (unsigned int p=0; p<n_qp; p++)
               this->d2phidxi2[i][p] = FE<Dim,T>::shape_second_deriv (elem, this->fe_type.order, i, 0, qp[p]);
 #endif // ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
 
         break;
       }
 
 
 
       //------------------------------------------------------------
       // 2D
     case 2:
       {
         // Compute the value of the approximation shape function i at quadrature point p
         if (this->calculate_dphiref)
           for (unsigned int i=0; i<n_approx_shape_functions; i++)
             for (unsigned int p=0; p<n_qp; p++)
               {
                 this->dphidxi[i][p]  = FE<Dim,T>::shape_deriv (elem, this->fe_type.order, i, 0, qp[p]);
                 this->dphideta[i][p] = FE<Dim,T>::shape_deriv (elem, this->fe_type.order, i, 1, qp[p]);
               }
 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
         if (this->calculate_d2phi)
           for (unsigned int i=0; i<n_approx_shape_functions; i++)
             for (unsigned int p=0; p<n_qp; p++)
               {
                 this->d2phidxi2[i][p] = FE<Dim,T>::shape_second_deriv (elem, this->fe_type.order, i, 0, qp[p]);
                 this->d2phidxideta[i][p] = FE<Dim,T>::shape_second_deriv (elem, this->fe_type.order, i, 1, qp[p]);
                 this->d2phideta2[i][p] = FE<Dim,T>::shape_second_deriv (elem, this->fe_type.order, i, 2, qp[p]);
               }
 #endif // ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
 
 
         break;
       }
 
 
 
       //------------------------------------------------------------
       // 3D
     case 3:
       {
         // Compute the value of the approximation shape function i at quadrature point p
         if (this->calculate_dphiref)
           for (unsigned int i=0; i<n_approx_shape_functions; i++)
             for (unsigned int p=0; p<n_qp; p++)
               {
                 this->dphidxi[i][p]   = FE<Dim,T>::shape_deriv (elem, this->fe_type.order, i, 0, qp[p]);
                 this->dphideta[i][p]  = FE<Dim,T>::shape_deriv (elem, this->fe_type.order, i, 1, qp[p]);
                 this->dphidzeta[i][p] = FE<Dim,T>::shape_deriv (elem, this->fe_type.order, i, 2, qp[p]);
               }
 #ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
         if (this->calculate_d2phi)
           for (unsigned int i=0; i<n_approx_shape_functions; i++)
             for (unsigned int p=0; p<n_qp; p++)
               {
                 this->d2phidxi2[i][p] = FE<Dim,T>::shape_second_deriv (elem, this->fe_type.order, i, 0, qp[p]);
                 this->d2phidxideta[i][p] = FE<Dim,T>::shape_second_deriv (elem, this->fe_type.order, i, 1, qp[p]);
                 this->d2phideta2[i][p] = FE<Dim,T>::shape_second_deriv (elem, this->fe_type.order, i, 2, qp[p]);
                 this->d2phidxidzeta[i][p] = FE<Dim,T>::shape_second_deriv (elem, this->fe_type.order, i, 3, qp[p]);
                 this->d2phidetadzeta[i][p] = FE<Dim,T>::shape_second_deriv (elem, this->fe_type.order, i, 4, qp[p]);
                 this->d2phidzeta2[i][p] = FE<Dim,T>::shape_second_deriv (elem, this->fe_type.order, i, 5, qp[p]);
               }
 #endif // ifdef LIBMESH_ENABLE_SECOND_DERIVATIVES
 
         break;
       }
 
 
     default:
       libmesh_error_msg("Invalid dimension Dim = " << Dim);
     }
 }

template<unsigned int Dim, FEFamily T>

Point libMesh::FE< Dim, T >::inverse_map	(	const Elem *	elem,
		const Point &	p,
		const Real	tolerance = `TOLERANCE`,
		const bool	secure = `true`
	)

static

Returns: The location (on the reference element) of the point p located in physical space. This function requires inverting the (possibly nonlinear) transformation map, so it is not trivial. The optional parameter tolerance defines how close is "good enough." The map inversion iteration computes the sequence $\{ p_n \}$ , and the iteration is terminated when $\|p - p_n\| < \mbox{\texttt{tolerance}}$

Definition at line 1566 of file fe_map.C.

References libMesh::TypeVector< T >::add(), libMesh::err, libMesh::DofObject::id(), libMesh::libmesh_assert(), libMesh::FE< Dim, T >::map(), libMesh::FE< Dim, T >::map_eta(), libMesh::FE< Dim, T >::map_xi(), libMesh::FE< Dim, T >::map_zeta(), libMesh::TypeVector< T >::norm(), libMesh::FEAbstract::on_reference_element(), libMesh::Elem::print_info(), libMesh::Real, and libMesh::Elem::type().

Referenced by libMesh::FEMap::compute_face_map().

 {
   libmesh_assert(elem);
   libmesh_assert_greater_equal (tolerance, 0.);
 
 
   // Start logging the map inversion.
   LOG_SCOPE("inverse_map()", "FE");
 
   // How much did the point on the reference
   // element change by in this Newton step?
   Real inverse_map_error = 0.;
 
   //  The point on the reference element.  This is
   //  the "initial guess" for Newton's method.  The
   //  centroid seems like a good idea, but computing
   //  it is a little more intensive than, say taking
   //  the zero point.
   //
   //  Convergence should be insensitive of this choice
   //  for "good" elements.
   Point p; // the zero point.  No computation required
 
   //  The number of iterations in the map inversion process.
   unsigned int cnt = 0;
 
   //  The number of iterations after which we give up and declare
   //  divergence
   const unsigned int max_cnt = 10;
 
   //  The distance (in master element space) beyond which we give up
   //  and declare divergence.  This is no longer used...
   // Real max_step_length = 4.;
 
 
 
   //  Newton iteration loop.
   do
     {
       //  Where our current iterate \p p maps to.
       const Point physical_guess = FE<Dim,T>::map (elem, p);
 
       //  How far our current iterate is from the actual point.
       const Point delta = physical_point - physical_guess;
 
       //  Increment in current iterate \p p, will be computed.
       Point dp;
 
 
       //  The form of the map and how we invert it depends
       //  on the dimension that we are in.
       switch (Dim)
         {
           // ------------------------------------------------------------------
           //  0D map inversion is trivial
         case 0:
           {
             break;
           }
 
           // ------------------------------------------------------------------
           //  1D map inversion
           //
           //  Here we find the point on a 1D reference element that maps to
           //  the point \p physical_point in the domain.  This is a bit tricky
           //  since we do not want to assume that the point \p physical_point
           //  is also in a 1D domain.  In particular, this method might get
           //  called on the edge of a 3D element, in which case
           //  \p physical_point actually lives in 3D.
         case 1:
           {
             const Point dxi = FE<Dim,T>::map_xi (elem, p);
 
             //  Newton's method in this case looks like
             //
             //  {X} - {X_n} = [J]*dp
             //
             //  Where {X}, {X_n} are 3x1 vectors, [J] is a 3x1 matrix
             //  d(x,y,z)/dxi, and we seek dp, a scalar.  Since the above
             //  system is either overdetermined or rank-deficient, we will
             //  solve the normal equations for this system
             //
             //  [J]^T ({X} - {X_n}) = [J]^T [J] {dp}
             //
             //  which involves the trivial inversion of the scalar
             //  G = [J]^T [J]
             const Real G = dxi*dxi;
 
             if (secure)
               libmesh_assert_greater (G, 0.);
 
             const Real Ginv = 1./G;
 
             const Real  dxidelta = dxi*delta;
 
             dp(0) = Ginv*dxidelta;
 
             // No master elements have radius > 4, but sometimes we
             // can take a step that big while still converging
             // if (secure)
             // libmesh_assert_less (dp.size(), max_step_length);
 
             break;
           }
 
 
 
           // ------------------------------------------------------------------
           //  2D map inversion
           //
           //  Here we find the point on a 2D reference element that maps to
           //  the point \p physical_point in the domain.  This is a bit tricky
           //  since we do not want to assume that the point \p physical_point
           //  is also in a 2D domain.  In particular, this method might get
           //  called on the face of a 3D element, in which case
           //  \p physical_point actually lives in 3D.
         case 2:
           {
             const Point dxi  = FE<Dim,T>::map_xi  (elem, p);
             const Point deta = FE<Dim,T>::map_eta (elem, p);
 
             //  Newton's method in this case looks like
             //
             //  {X} - {X_n} = [J]*{dp}
             //
             //  Where {X}, {X_n} are 3x1 vectors, [J] is a 3x2 matrix
             //  d(x,y,z)/d(xi,eta), and we seek {dp}, a 2x1 vector.  Since
             //  the above system is either overdermined or rank-deficient,
             //  we will solve the normal equations for this system
             //
             //  [J]^T ({X} - {X_n}) = [J]^T [J] {dp}
             //
             //  which involves the inversion of the 2x2 matrix
             //  [G] = [J]^T [J]
             const Real
               G11 = dxi*dxi,  G12 = dxi*deta,
               G21 = dxi*deta, G22 = deta*deta;
 
 
             const Real det = (G11*G22 - G12*G21);
 
             if (secure)
               libmesh_assert_not_equal_to (det, 0.);
 
             const Real inv_det = 1./det;
 
             const Real
               Ginv11 =  G22*inv_det,
               Ginv12 = -G12*inv_det,
 
               Ginv21 = -G21*inv_det,
               Ginv22 =  G11*inv_det;
 
 
             const Real  dxidelta  = dxi*delta;
             const Real  detadelta = deta*delta;
 
             dp(0) = (Ginv11*dxidelta + Ginv12*detadelta);
             dp(1) = (Ginv21*dxidelta + Ginv22*detadelta);
 
             // No master elements have radius > 4, but sometimes we
             // can take a step that big while still converging
             // if (secure)
             // libmesh_assert_less (dp.size(), max_step_length);
 
             break;
           }
 
 
 
           // ------------------------------------------------------------------
           //  3D map inversion
           //
           //  Here we find the point in a 3D reference element that maps to
           //  the point \p physical_point in a 3D domain. Nothing special
           //  has to happen here, since (unless the map is singular because
           //  you have a BAD element) the map will be invertable and we can
           //  apply Newton's method directly.
         case 3:
           {
             const Point dxi   = FE<Dim,T>::map_xi   (elem, p);
             const Point deta  = FE<Dim,T>::map_eta  (elem, p);
             const Point dzeta = FE<Dim,T>::map_zeta (elem, p);
 
             //  Newton's method in this case looks like
             //
             //  {X} = {X_n} + [J]*{dp}
             //
             //  Where {X}, {X_n} are 3x1 vectors, [J] is a 3x3 matrix
             //  d(x,y,z)/d(xi,eta,zeta), and we seek {dp}, a 3x1 vector.
             //  Since the above system is nonsingular for invertable maps
             //  we will solve
             //
             //  {dp} = [J]^-1 ({X} - {X_n})
             //
             //  which involves the inversion of the 3x3 matrix [J]
             libmesh_try
               {
                 RealTensorValue(dxi(0), deta(0), dzeta(0),
                                 dxi(1), deta(1), dzeta(1),
                                 dxi(2), deta(2), dzeta(2)).solve(delta, dp);
               }
             libmesh_catch (ConvergenceFailure &)
               {
                 // We encountered a singular Jacobian.  The value of
                 // dp is zero, since it was never changed during the
                 // call to RealTensorValue::solve().  We don't want to
                 // continue iterating until max_cnt since there is no
                 // update to the Newton iterate, and we don't want to
                 // print the inverse_map_error value since it will
                 // confusingly be 0.  Therefore, in the secure case we
                 // need to throw an error message while in the !secure
                 // case we can just return a far away point.
                 if (secure)
                   {
                     libMesh::err << "ERROR: Newton scheme encountered a singular Jacobian in element: "
                                  << elem->id()
                                  << std::endl;
 
                     elem->print_info(libMesh::err);
 
                     libmesh_error_msg("Exiting...");
                   }
                 else
                   {
                     for (unsigned int i=0; i != Dim; ++i)
                       p(i) = 1e6;
                     return p;
                   }
               }
 
             // No master elements have radius > 4, but sometimes we
             // can take a step that big while still converging
             // if (secure)
             // libmesh_assert_less (dp.size(), max_step_length);
 
             break;
           }
 
 
           //  Some other dimension?
         default:
           libmesh_error_msg("Invalid Dim = " << Dim);
         } // end switch(Dim), dp now computed
 
 
 
       //  ||P_n+1 - P_n||
       inverse_map_error = dp.norm();
 
       //  P_n+1 = P_n + dp
       p.add (dp);
 
       //  Increment the iteration count.
       cnt++;
 
       //  Watch for divergence of Newton's
       //  method.  Here's how it goes:
       //  (1) For good elements, we expect convergence in 10
       //      iterations, with no too-large steps.
       //      - If called with (secure == true) and we have not yet converged
       //        print out a warning message.
       //      - If called with (secure == true) and we have not converged in
       //        20 iterations abort
       //  (2) This method may be called in cases when the target point is not
       //      inside the element and we have no business expecting convergence.
       //      For these cases if we have not converged in 10 iterations forget
       //      about it.
       if (cnt > max_cnt)
         {
           //  Warn about divergence when secure is true - this
           //  shouldn't happen
           if (secure)
             {
               // Print every time in devel/dbg modes
 #ifndef NDEBUG
               libmesh_here();
               libMesh::err << "WARNING: Newton scheme has not converged in "
                            << cnt << " iterations:" << std::endl
                            << "   physical_point="
                            << physical_point
                            << "   physical_guess="
                            << physical_guess
                            << "   dp="
                            << dp
                            << "   p="
                            << p
                            << "   error=" << inverse_map_error
                            << "   in element " << elem->id()
                            << std::endl;
 
               elem->print_info(libMesh::err);
 #else
               // In optimized mode, just print once that an inverse_map() call
               // had trouble converging its Newton iteration.
               libmesh_do_once(libMesh::err << "WARNING: At least one element took more than "
                               << max_cnt
                               << " iterations to converge in inverse_map()...\n"
                               << "Rerun in devel/dbg mode for more details."
                               << std::endl;);
 
 #endif // NDEBUG
 
               if (cnt > 2*max_cnt)
                 {
                   libMesh::err << "ERROR: Newton scheme FAILED to converge in "
                                << cnt
                                << " iterations in element "
                                << elem->id()
                                << " for physical point = "
                                << physical_point
                                << std::endl;
 
                   elem->print_info(libMesh::err);
 
                   libmesh_error_msg("Exiting...");
                 }
             }
           //  Return a far off point when secure is false - this
           //  should only happen when we're trying to map a point
           //  that's outside the element
           else
             {
               for (unsigned int i=0; i != Dim; ++i)
                 p(i) = 1e6;
 
               return p;
             }
         }
     }
   while (inverse_map_error > tolerance);
 
 
 
   //  If we are in debug mode do two sanity checks.
 #ifdef DEBUG
 
   if (secure)
     {
       // Make sure the point \p p on the reference element actually
       // does map to the point \p physical_point within a tolerance.
 
       const Point check = FE<Dim,T>::map (elem, p);
       const Point diff  = physical_point - check;
 
       if (diff.norm() > tolerance)
         {
           libmesh_here();
           libMesh::err << "WARNING:  diff is "
                        << diff.norm()
                        << std::endl
                        << " point="
                        << physical_point;
           libMesh::err << " local=" << check;
           libMesh::err << " lref= " << p;
 
           elem->print_info(libMesh::err);
         }
 
       // Make sure the point \p p on the reference element actually
       // is
 
       if (!FEAbstract::on_reference_element(p, elem->type(), 2*tolerance))
         {
           libmesh_here();
           libMesh::err << "WARNING:  inverse_map of physical point "
                        << physical_point
                        << " is not on element." << '\n';
           elem->print_info(libMesh::err);
         }
     }
 
 #endif
 
   return p;
 }

template<unsigned int Dim, FEFamily T>

void libMesh::FE< Dim, T >::inverse_map	(	const Elem *	elem,
		const std::vector< Point > &	physical_points,
		std::vector< Point > &	reference_points,
		const Real	tolerance = `TOLERANCE`,
		const bool	secure = `true`
	)

static

Takes a number points in physical space (in the physical_points vector) and finds their location on the reference element for the input element elem. The values on the reference element are returned in the vector reference_points. The optional parameter tolerance defines how close is "good enough." The map inversion iteration computes the sequence $\{ p_n \}$ , and the iteration is terminated when $\|p - p_n\| < \mbox{\texttt{tolerance}}$

Definition at line 1950 of file fe_map.C.

References libMesh::TypeVector< T >::size().

 {
   // The number of points to find the
   // inverse map of
   const std::size_t n_points = physical_points.size();
 
   // Resize the vector to hold the points
   // on the reference element
   reference_points.resize(n_points);
 
   // Find the coordinates on the reference
   // element of each point in physical space
   for (std::size_t p=0; p<n_points; p++)
     reference_points[p] =
       FE<Dim,T>::inverse_map (elem, physical_points[p], tolerance, secure);
 }

template<>

Point libMesh::FE< 2, SUBDIVISION >::inverse_map	(	const Elem *	,
		const Point &	,
		const Real	,
		const bool
	)

Definition at line 894 of file fe_subdivision_2D.C.

 {
   libmesh_not_implemented();
 }

template<>

void libMesh::FE< 2, SUBDIVISION >::inverse_map	(	const Elem *	,
		const std::vector< Point > &	,
		std::vector< Point > &	,
		Real	,
		bool
	)

Definition at line 903 of file fe_subdivision_2D.C.

 {
   libmesh_not_implemented();
 }

template<>

bool libMesh::FE< 0, SCALAR >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 113 of file fe_scalar.C.

113 { return false; }

template<>

bool libMesh::FE< 1, SCALAR >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 114 of file fe_scalar.C.

114 { return false; }

template<>

bool libMesh::FE< 2, SCALAR >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 115 of file fe_scalar.C.

115 { return false; }

template<>

bool libMesh::FE< 3, SCALAR >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 116 of file fe_scalar.C.

116 { return false; }

template<>

bool libMesh::FE< 0, L2_HIERARCHIC >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 200 of file fe_l2_hierarchic.C.

200 { return true; }

template<>

bool libMesh::FE< 1, L2_HIERARCHIC >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 201 of file fe_l2_hierarchic.C.

201 { return true; }

template<>

bool libMesh::FE< 2, L2_HIERARCHIC >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 202 of file fe_l2_hierarchic.C.

202 { return true; }

template<>

bool libMesh::FE< 3, L2_HIERARCHIC >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 203 of file fe_l2_hierarchic.C.

203 { return true; }

template<unsigned int Dim, FEFamily T>

virtual bool libMesh::FE< Dim, T >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

template<>

bool libMesh::FE< 0, CLOUGH >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 305 of file fe_clough.C.

305 { return false; } // FIXME - this will be changed

template<>

bool libMesh::FE< 1, CLOUGH >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 306 of file fe_clough.C.

306 { return false; } // FIXME - this will be changed

template<>

bool libMesh::FE< 2, CLOUGH >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 307 of file fe_clough.C.

307 { return false; } // FIXME - this will be changed

template<>

bool libMesh::FE< 3, CLOUGH >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 308 of file fe_clough.C.

308 { return false; } // FIXME - this will be changed

template<>

bool libMesh::FE< 0, HERMITE >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 345 of file fe_hermite.C.

345 { return true; }

template<>

bool libMesh::FE< 1, HERMITE >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 346 of file fe_hermite.C.

346 { return true; }

template<>

bool libMesh::FE< 2, HERMITE >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 347 of file fe_hermite.C.

347 { return true; }

template<>

bool libMesh::FE< 3, HERMITE >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 348 of file fe_hermite.C.

348 { return true; }

template<>

bool libMesh::FE< 0, HIERARCHIC >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 373 of file fe_hierarchic.C.

373 { return true; }

template<>

bool libMesh::FE< 1, HIERARCHIC >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 374 of file fe_hierarchic.C.

374 { return true; }

template<>

bool libMesh::FE< 2, HIERARCHIC >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 375 of file fe_hierarchic.C.

375 { return true; }

template<>

bool libMesh::FE< 3, HIERARCHIC >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 376 of file fe_hierarchic.C.

376 { return true; }

template<>

bool libMesh::FE< 0, MONOMIAL >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 407 of file fe_monomial.C.

407 { return true; }

template<>

bool libMesh::FE< 1, MONOMIAL >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 408 of file fe_monomial.C.

408 { return true; }

template<>

bool libMesh::FE< 2, MONOMIAL >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 409 of file fe_monomial.C.

409 { return true; }

template<>

bool libMesh::FE< 3, MONOMIAL >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 410 of file fe_monomial.C.

410 { return true; }

template<>

bool libMesh::FE< 0, BERNSTEIN >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 436 of file fe_bernstein.C.

436 { return false; }

template<>

bool libMesh::FE< 1, BERNSTEIN >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 437 of file fe_bernstein.C.

437 { return false; }

template<>

bool libMesh::FE< 2, BERNSTEIN >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 438 of file fe_bernstein.C.

438 { return false; }

template<>

bool libMesh::FE< 3, BERNSTEIN >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 439 of file fe_bernstein.C.

439 { return false; }

template<>

bool libMesh::FE< 0, L2_LAGRANGE >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 481 of file fe_l2_lagrange.C.

481 { return false; }

template<>

bool libMesh::FE< 1, L2_LAGRANGE >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 482 of file fe_l2_lagrange.C.

482 { return false; }

template<>

bool libMesh::FE< 2, L2_LAGRANGE >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 483 of file fe_l2_lagrange.C.

483 { return false; }

template<>

bool libMesh::FE< 3, L2_LAGRANGE >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 484 of file fe_l2_lagrange.C.

484 { return false; }

template<>

bool libMesh::FE< 0, NEDELEC_ONE >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 556 of file fe_nedelec_one.C.

556 { NEDELEC_LOW_D_ERROR_MESSAGE }

template<>

bool libMesh::FE< 1, NEDELEC_ONE >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 557 of file fe_nedelec_one.C.

557 { NEDELEC_LOW_D_ERROR_MESSAGE }

template<>

bool libMesh::FE< 2, NEDELEC_ONE >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 558 of file fe_nedelec_one.C.

558 { return false; }

template<>

bool libMesh::FE< 3, NEDELEC_ONE >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 559 of file fe_nedelec_one.C.

559 { return false; }

template<>

bool libMesh::FE< 0, LAGRANGE >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 884 of file fe_lagrange.C.

884 { return false; }

template<>

bool libMesh::FE< 1, LAGRANGE >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 885 of file fe_lagrange.C.

885 { return false; }

template<>

bool libMesh::FE< 2, LAGRANGE >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 886 of file fe_lagrange.C.

886 { return false; }

template<>

bool libMesh::FE< 3, LAGRANGE >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 887 of file fe_lagrange.C.

887 { return false; }

template<>

bool libMesh::FE< 0, XYZ >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 922 of file fe_xyz.C.

922 { return true; }

template<>

bool libMesh::FE< 1, XYZ >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 923 of file fe_xyz.C.

923 { return true; }

template<>

bool libMesh::FE< 2, XYZ >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 924 of file fe_xyz.C.

924 { return true; }

template<>

bool libMesh::FE< 3, XYZ >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 925 of file fe_xyz.C.

925 { return true; }

template<>

bool libMesh::FE< 2, SUBDIVISION >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 931 of file fe_subdivision_2D.C.

931 { return false; }

template<>

bool libMesh::FE< 0, LAGRANGE_VEC >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 933 of file fe_lagrange_vec.C.

933 { return false; }

template<>

bool libMesh::FE< 1, LAGRANGE_VEC >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 934 of file fe_lagrange_vec.C.

934 { return false; }

template<>

bool libMesh::FE< 2, LAGRANGE_VEC >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 935 of file fe_lagrange_vec.C.

935 { return false; }

template<>

bool libMesh::FE< 3, LAGRANGE_VEC >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 936 of file fe_lagrange_vec.C.

936 { return false; }

template<>

bool libMesh::FE< 0, SZABAB >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 1285 of file fe_szabab.C.

1285 { return true; }

template<>

bool libMesh::FE< 1, SZABAB >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 1286 of file fe_szabab.C.

1286 { return true; }

template<>

bool libMesh::FE< 2, SZABAB >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 1287 of file fe_szabab.C.

1287 { return true; }

template<>

bool libMesh::FE< 3, SZABAB >::is_hierarchic ( ) const

virtual

Returns: true if the finite element's higher order shape functions are hierarchic

Implements libMesh::FEAbstract.

Definition at line 1288 of file fe_szabab.C.

1288 { return true; }

template<unsigned int Dim, FEFamily T>

Point libMesh::FE< Dim, T >::map	(	const Elem *	elem,
		const Point &	reference_point
	)

static

Returns: The location (in physical space) of the point p located on the reference element.

Definition at line 1975 of file fe_map.C.

References libMesh::TypeVector< T >::add_scaled(), libMesh::Elem::default_order(), libMesh::libmesh_assert(), libMesh::FE< Dim, T >::n_shape_functions(), libMesh::Elem::point(), libMesh::FE< Dim, T >::shape(), and libMesh::Elem::type().

Referenced by libMesh::FE< Dim, T >::inverse_map(), libMesh::InfFE< Dim, T_radial, T_map >::inverse_map(), and libMesh::InfFE< Dim, T_radial, T_map >::map().

 {
   libmesh_assert(elem);
 
   Point p;
 
   const ElemType type     = elem->type();
   const Order order       = elem->default_order();
   const unsigned int n_sf = FE<Dim,LAGRANGE>::n_shape_functions(type, order);
 
   // Lagrange basis functions are used for mapping
   for (unsigned int i=0; i<n_sf; i++)
     p.add_scaled (elem->point(i),
                   FE<Dim,LAGRANGE>::shape(type,
                                           order,
                                           i,
                                           reference_point)
                   );
 
   return p;
 }

template<unsigned int Dim, FEFamily T>

Point libMesh::FE< Dim, T >::map_eta	(	const Elem *	elem,
		const Point &	reference_point
	)

static

Returns: d(xyz)/deta (in physical space) of the point p located on the reference element.

Definition at line 2030 of file fe_map.C.

References libMesh::TypeVector< T >::add_scaled(), libMesh::Elem::default_order(), libMesh::libmesh_assert(), libMesh::FE< Dim, T >::n_shape_functions(), libMesh::Elem::point(), libMesh::FE< Dim, T >::shape_deriv(), and libMesh::Elem::type().

Referenced by libMesh::FEMap::compute_face_map(), libMesh::FE< Dim, T >::inverse_map(), and libMesh::InfFE< Dim, T_radial, T_map >::inverse_map().

 {
   libmesh_assert(elem);
 
   Point p;
 
   const ElemType type     = elem->type();
   const Order order       = elem->default_order();
   const unsigned int n_sf = FE<Dim,LAGRANGE>::n_shape_functions(type, order);
 
   // Lagrange basis functions are used for mapping
   for (unsigned int i=0; i<n_sf; i++)
     p.add_scaled (elem->point(i),
                   FE<Dim,LAGRANGE>::shape_deriv(type,
                                                 order,
                                                 i,
                                                 1,
                                                 reference_point)
                   );
 
   return p;
 }

template<unsigned int Dim, FEFamily T>

Point libMesh::FE< Dim, T >::map_xi	(	const Elem *	elem,
		const Point &	reference_point
	)

static

Returns: d(xyz)/dxi (in physical space) of the point p located on the reference element.

Definition at line 2002 of file fe_map.C.

References libMesh::TypeVector< T >::add_scaled(), libMesh::Elem::default_order(), libMesh::libmesh_assert(), libMesh::FE< Dim, T >::n_shape_functions(), libMesh::Elem::point(), libMesh::FE< Dim, T >::shape_deriv(), and libMesh::Elem::type().

Referenced by libMesh::FEMap::compute_face_map(), libMesh::FE< Dim, T >::inverse_map(), and libMesh::InfFE< Dim, T_radial, T_map >::inverse_map().

 {
   libmesh_assert(elem);
 
   Point p;
 
   const ElemType type     = elem->type();
   const Order order       = elem->default_order();
   const unsigned int n_sf = FE<Dim,LAGRANGE>::n_shape_functions(type, order);
 
   // Lagrange basis functions are used for mapping
   for (unsigned int i=0; i<n_sf; i++)
     p.add_scaled (elem->point(i),
                   FE<Dim,LAGRANGE>::shape_deriv(type,
                                                 order,
                                                 i,
                                                 0,
                                                 reference_point)
                   );
 
   return p;
 }

template<unsigned int Dim, FEFamily T>

Point libMesh::FE< Dim, T >::map_zeta	(	const Elem *	elem,
		const Point &	reference_point
	)

static

Returns: d(xyz)/dzeta (in physical space) of the point p located on the reference element.

Definition at line 2058 of file fe_map.C.

References libMesh::TypeVector< T >::add_scaled(), libMesh::Elem::default_order(), libMesh::INSTANTIATE_ALL_MAPS(), libMesh::libmesh_assert(), libMesh::FE< Dim, T >::n_shape_functions(), libMesh::Elem::point(), libMesh::FE< Dim, T >::shape_deriv(), and libMesh::Elem::type().

Referenced by libMesh::FE< Dim, T >::inverse_map().

 {
   libmesh_assert(elem);
 
   Point p;
 
   const ElemType type     = elem->type();
   const Order order       = elem->default_order();
   const unsigned int n_sf = FE<Dim,LAGRANGE>::n_shape_functions(type, order);
 
   // Lagrange basis functions are used for mapping
   for (unsigned int i=0; i<n_sf; i++)
     p.add_scaled (elem->point(i),
                   FE<Dim,LAGRANGE>::shape_deriv(type,
                                                 order,
                                                 i,
                                                 2,
                                                 reference_point)
                   );
 
   return p;
 }

template<>

unsigned int libMesh::FE< 0, SCALAR >::n_dofs	(	const ElemType	,
		const Order	o
	)

Definition at line 87 of file fe_scalar.C.

87 { return o; }

template<>

unsigned int libMesh::FE< 1, SCALAR >::n_dofs	(	const ElemType	,
		const Order	o
	)

Definition at line 88 of file fe_scalar.C.

88 { return o; }

template<>

unsigned int libMesh::FE< 2, SCALAR >::n_dofs	(	const ElemType	,
		const Order	o
	)

Definition at line 89 of file fe_scalar.C.

89 { return o; }

template<>

unsigned int libMesh::FE< 3, SCALAR >::n_dofs	(	const ElemType	,
		const Order	o
	)

Definition at line 90 of file fe_scalar.C.

90 { return o; }

template<>

unsigned int libMesh::FE< 0, L2_HIERARCHIC >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 175 of file fe_l2_hierarchic.C.

175 { return l2_hierarchic_n_dofs(t, o); }

template<>

unsigned int libMesh::FE< 1, L2_HIERARCHIC >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 176 of file fe_l2_hierarchic.C.

176 { return l2_hierarchic_n_dofs(t, o); }

template<>

unsigned int libMesh::FE< 2, L2_HIERARCHIC >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 177 of file fe_l2_hierarchic.C.

177 { return l2_hierarchic_n_dofs(t, o); }

template<>

unsigned int libMesh::FE< 3, L2_HIERARCHIC >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 178 of file fe_l2_hierarchic.C.

178 { return l2_hierarchic_n_dofs(t, o); }

template<unsigned int Dim, FEFamily T>

static unsigned int libMesh::FE< Dim, T >::n_dofs	(	const ElemType	t,
		const Order	o
	)

static

Returns: The number of shape functions associated with this finite element.

On a p-refined element, o should be the total order of the element.

Referenced by libMesh::FE< Dim, T >::n_dofs(), libMesh::FE< Dim, T >::n_shape_functions(), and libMesh::FE< Dim, LAGRANGE_VEC >::n_shape_functions().

template<>

unsigned int libMesh::FE< 0, CLOUGH >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 280 of file fe_clough.C.

280 { return clough_n_dofs(t, o); }

template<>

unsigned int libMesh::FE< 1, CLOUGH >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 281 of file fe_clough.C.

281 { return clough_n_dofs(t, o); }

template<>

unsigned int libMesh::FE< 2, CLOUGH >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 282 of file fe_clough.C.

282 { return clough_n_dofs(t, o); }

template<>

unsigned int libMesh::FE< 3, CLOUGH >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 283 of file fe_clough.C.

283 { return clough_n_dofs(t, o); }

template<>

unsigned int libMesh::FE< 0, HERMITE >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 320 of file fe_hermite.C.

320 { return hermite_n_dofs(t, o); }

template<>

unsigned int libMesh::FE< 1, HERMITE >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 321 of file fe_hermite.C.

321 { return hermite_n_dofs(t, o); }

template<>

unsigned int libMesh::FE< 2, HERMITE >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 322 of file fe_hermite.C.

322 { return hermite_n_dofs(t, o); }

template<>

unsigned int libMesh::FE< 3, HERMITE >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 323 of file fe_hermite.C.

323 { return hermite_n_dofs(t, o); }

template<>

unsigned int libMesh::FE< 0, HIERARCHIC >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 349 of file fe_hierarchic.C.

349 { return hierarchic_n_dofs(t, o); }

template<>

unsigned int libMesh::FE< 1, HIERARCHIC >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 350 of file fe_hierarchic.C.

350 { return hierarchic_n_dofs(t, o); }

template<>

unsigned int libMesh::FE< 2, HIERARCHIC >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 351 of file fe_hierarchic.C.

351 { return hierarchic_n_dofs(t, o); }

template<>

unsigned int libMesh::FE< 3, HIERARCHIC >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 352 of file fe_hierarchic.C.

352 { return hierarchic_n_dofs(t, o); }

template<>

unsigned int libMesh::FE< 0, MONOMIAL >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 380 of file fe_monomial.C.

380 { return monomial_n_dofs(t, o); }

template<>

unsigned int libMesh::FE< 1, MONOMIAL >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 381 of file fe_monomial.C.

381 { return monomial_n_dofs(t, o); }

template<>

unsigned int libMesh::FE< 2, MONOMIAL >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 382 of file fe_monomial.C.

382 { return monomial_n_dofs(t, o); }

template<>

unsigned int libMesh::FE< 3, MONOMIAL >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 383 of file fe_monomial.C.

383 { return monomial_n_dofs(t, o); }

template<>

unsigned int libMesh::FE< 0, BERNSTEIN >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 412 of file fe_bernstein.C.

412 { return bernstein_n_dofs(t, o); }

template<>

unsigned int libMesh::FE< 1, BERNSTEIN >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 413 of file fe_bernstein.C.

413 { return bernstein_n_dofs(t, o); }

template<>

unsigned int libMesh::FE< 2, BERNSTEIN >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 414 of file fe_bernstein.C.

414 { return bernstein_n_dofs(t, o); }

template<>

unsigned int libMesh::FE< 3, BERNSTEIN >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 415 of file fe_bernstein.C.

415 { return bernstein_n_dofs(t, o); }

template<>

unsigned int libMesh::FE< 0, L2_LAGRANGE >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 455 of file fe_l2_lagrange.C.

455 { return l2_lagrange_n_dofs(t, o); }

template<>

unsigned int libMesh::FE< 1, L2_LAGRANGE >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 456 of file fe_l2_lagrange.C.

456 { return l2_lagrange_n_dofs(t, o); }

template<>

unsigned int libMesh::FE< 2, L2_LAGRANGE >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 457 of file fe_l2_lagrange.C.

457 { return l2_lagrange_n_dofs(t, o); }

template<>

unsigned int libMesh::FE< 3, L2_LAGRANGE >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 458 of file fe_l2_lagrange.C.

458 { return l2_lagrange_n_dofs(t, o); }

template<>

unsigned int libMesh::FE< 0, NEDELEC_ONE >::n_dofs	(	const ElemType	,
		const Order
	)

Definition at line 528 of file fe_nedelec_one.C.

528 { NEDELEC_LOW_D_ERROR_MESSAGE }

template<>

unsigned int libMesh::FE< 1, NEDELEC_ONE >::n_dofs	(	const ElemType	,
		const Order
	)

Definition at line 529 of file fe_nedelec_one.C.

529 { NEDELEC_LOW_D_ERROR_MESSAGE }

template<>

unsigned int libMesh::FE< 2, NEDELEC_ONE >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 530 of file fe_nedelec_one.C.

530 { return nedelec_one_n_dofs(t, o); }

template<>

unsigned int libMesh::FE< 3, NEDELEC_ONE >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 531 of file fe_nedelec_one.C.

531 { return nedelec_one_n_dofs(t, o); }

template<>

unsigned int libMesh::FE< 0, LAGRANGE >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 856 of file fe_lagrange.C.

856 { return lagrange_n_dofs(t, o); }

template<>

unsigned int libMesh::FE< 1, LAGRANGE >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 857 of file fe_lagrange.C.

857 { return lagrange_n_dofs(t, o); }

template<>

unsigned int libMesh::FE< 2, LAGRANGE >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 858 of file fe_lagrange.C.

858 { return lagrange_n_dofs(t, o); }

template<>

unsigned int libMesh::FE< 3, LAGRANGE >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 859 of file fe_lagrange.C.

859 { return lagrange_n_dofs(t, o); }

template<>

unsigned int libMesh::FE< 0, XYZ >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 896 of file fe_xyz.C.

896 { return xyz_n_dofs(t, o); }

template<>

unsigned int libMesh::FE< 1, XYZ >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 897 of file fe_xyz.C.

897 { return xyz_n_dofs(t, o); }

template<>

unsigned int libMesh::FE< 2, XYZ >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 898 of file fe_xyz.C.

898 { return xyz_n_dofs(t, o); }

template<>

unsigned int libMesh::FE< 3, XYZ >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 899 of file fe_xyz.C.

899 { return xyz_n_dofs(t, o); }

template<>

unsigned int libMesh::FE< 0, LAGRANGE_VEC >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 905 of file fe_lagrange_vec.C.

905 { return FE<0,LAGRANGE>::n_dofs(t,o); }

static unsigned int n_dofs(const ElemType t, const Order o)

template<>

unsigned int libMesh::FE< 1, LAGRANGE_VEC >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 906 of file fe_lagrange_vec.C.

906 { return FE<1,LAGRANGE>::n_dofs(t,o); }

static unsigned int n_dofs(const ElemType t, const Order o)

template<>

unsigned int libMesh::FE< 2, LAGRANGE_VEC >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 907 of file fe_lagrange_vec.C.

907 { return 2*FE<2,LAGRANGE>::n_dofs(t,o); }

static unsigned int n_dofs(const ElemType t, const Order o)

template<>

unsigned int libMesh::FE< 3, LAGRANGE_VEC >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 908 of file fe_lagrange_vec.C.

908 { return 3*FE<3,LAGRANGE>::n_dofs(t,o); }

static unsigned int n_dofs(const ElemType t, const Order o)

template<>

unsigned int libMesh::FE< 2, SUBDIVISION >::n_dofs	(	const ElemType	,
		const Order
	)

Definition at line 915 of file fe_subdivision_2D.C.

915 { libmesh_not_implemented(); return 0; }

template<>

unsigned int libMesh::FE< 0, SZABAB >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 1261 of file fe_szabab.C.

1261 { return szabab_n_dofs(t, o); }

template<>

unsigned int libMesh::FE< 1, SZABAB >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 1262 of file fe_szabab.C.

1262 { return szabab_n_dofs(t, o); }

template<>

unsigned int libMesh::FE< 2, SZABAB >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 1263 of file fe_szabab.C.

1263 { return szabab_n_dofs(t, o); }

template<>

unsigned int libMesh::FE< 3, SZABAB >::n_dofs	(	const ElemType	t,
		const Order	o
	)

Definition at line 1264 of file fe_szabab.C.

1264 { return szabab_n_dofs(t, o); }

template<>

unsigned int libMesh::FE< 0, SCALAR >::n_dofs_at_node	(	const ElemType	,
		const Order	,
		const unsigned	int
	)

Definition at line 94 of file fe_scalar.C.

94 { return 0; }

template<>

unsigned int libMesh::FE< 1, SCALAR >::n_dofs_at_node	(	const ElemType	,
		const Order	,
		const unsigned	int
	)

Definition at line 95 of file fe_scalar.C.

95 { return 0; }

template<>

unsigned int libMesh::FE< 2, SCALAR >::n_dofs_at_node	(	const ElemType	,
		const Order	,
		const unsigned	int
	)

Definition at line 96 of file fe_scalar.C.

96 { return 0; }

template<>

unsigned int libMesh::FE< 3, SCALAR >::n_dofs_at_node	(	const ElemType	,
		const Order	,
		const unsigned	int
	)

Definition at line 97 of file fe_scalar.C.

97 { return 0; }

template<>

unsigned int libMesh::FE< 0, L2_HIERARCHIC >::n_dofs_at_node	(	const ElemType	,
		const Order	,
		const unsigned	int
	)

Definition at line 182 of file fe_l2_hierarchic.C.

182 { return 0; }

template<>

unsigned int libMesh::FE< 1, L2_HIERARCHIC >::n_dofs_at_node	(	const ElemType	,
		const Order	,
		const unsigned	int
	)

Definition at line 183 of file fe_l2_hierarchic.C.

183 { return 0; }

template<>

unsigned int libMesh::FE< 2, L2_HIERARCHIC >::n_dofs_at_node	(	const ElemType	,
		const Order	,
		const unsigned	int
	)

Definition at line 184 of file fe_l2_hierarchic.C.

184 { return 0; }

template<>

unsigned int libMesh::FE< 3, L2_HIERARCHIC >::n_dofs_at_node	(	const ElemType	,
		const Order	,
		const unsigned	int
	)

Definition at line 185 of file fe_l2_hierarchic.C.

185 { return 0; }

template<unsigned int Dim, FEFamily T>

static unsigned int libMesh::FE< Dim, T >::n_dofs_at_node	(	const ElemType	t,
		const Order	o,
		const unsigned int	n
	)

static

Returns: The number of dofs at node n for a finite element of type t and order o.

On a p-refined element, o should be the total order of the element.

Referenced by libMesh::FE< Dim, T >::n_dofs_at_node().

template<>

unsigned int libMesh::FE< 0, CLOUGH >::n_dofs_at_node	(	const ElemType	t,
		const Order	o,
		const unsigned int	n
	)

Definition at line 287 of file fe_clough.C.

287 { return clough_n_dofs_at_node(t, o, n); }

template<>

unsigned int libMesh::FE< 1, CLOUGH >::n_dofs_at_node	(	const ElemType	t,
		const Order	o,
		const unsigned int	n
	)

Definition at line 288 of file fe_clough.C.

288 { return clough_n_dofs_at_node(t, o, n); }

template<>

unsigned int libMesh::FE< 2, CLOUGH >::n_dofs_at_node	(	const ElemType	t,
		const Order	o,
		const unsigned int	n
	)

Definition at line 289 of file fe_clough.C.

289 { return clough_n_dofs_at_node(t, o, n); }

template<>

unsigned int libMesh::FE< 3, CLOUGH >::n_dofs_at_node	(	const ElemType	t,
		const Order	o,
		const unsigned int	n
	)

Definition at line 290 of file fe_clough.C.

290 { return clough_n_dofs_at_node(t, o, n); }

template<>

unsigned int libMesh::FE< 0, HERMITE >::n_dofs_at_node	(	const ElemType	t,
		const Order	o,
		const unsigned int	n
	)

Definition at line 327 of file fe_hermite.C.

327 { return hermite_n_dofs_at_node(t, o, n); }

template<>

unsigned int libMesh::FE< 1, HERMITE >::n_dofs_at_node	(	const ElemType	t,
		const Order	o,
		const unsigned int	n
	)

Definition at line 328 of file fe_hermite.C.

328 { return hermite_n_dofs_at_node(t, o, n); }

template<>

unsigned int libMesh::FE< 2, HERMITE >::n_dofs_at_node	(	const ElemType	t,
		const Order	o,
		const unsigned int	n
	)

Definition at line 329 of file fe_hermite.C.

329 { return hermite_n_dofs_at_node(t, o, n); }

template<>

unsigned int libMesh::FE< 3, HERMITE >::n_dofs_at_node	(	const ElemType	t,
		const Order	o,
		const unsigned int	n
	)

Definition at line 330 of file fe_hermite.C.

330 { return hermite_n_dofs_at_node(t, o, n); }

template<>

unsigned int libMesh::FE< 0, HIERARCHIC >::n_dofs_at_node	(	const ElemType	t,
		const Order	o,
		const unsigned int	n
	)

Definition at line 355 of file fe_hierarchic.C.

355 { return hierarchic_n_dofs_at_node(t, o, n); }

template<>

unsigned int libMesh::FE< 1, HIERARCHIC >::n_dofs_at_node	(	const ElemType	t,
		const Order	o,
		const unsigned int	n
	)

Definition at line 356 of file fe_hierarchic.C.

356 { return hierarchic_n_dofs_at_node(t, o, n); }

template<>

unsigned int libMesh::FE< 2, HIERARCHIC >::n_dofs_at_node	(	const ElemType	t,
		const Order	o,
		const unsigned int	n
	)

Definition at line 357 of file fe_hierarchic.C.

357 { return hierarchic_n_dofs_at_node(t, o, n); }

template<>

unsigned int libMesh::FE< 3, HIERARCHIC >::n_dofs_at_node	(	const ElemType	t,
		const Order	o,
		const unsigned int	n
	)

Definition at line 358 of file fe_hierarchic.C.

358 { return hierarchic_n_dofs_at_node(t, o, n); }

template<>

unsigned int libMesh::FE< 0, MONOMIAL >::n_dofs_at_node	(	const ElemType	,
		const Order	,
		const unsigned	int
	)

Definition at line 387 of file fe_monomial.C.

387 { return 0; }

template<>

unsigned int libMesh::FE< 1, MONOMIAL >::n_dofs_at_node	(	const ElemType	,
		const Order	,
		const unsigned	int
	)

Definition at line 388 of file fe_monomial.C.

388 { return 0; }

template<>

unsigned int libMesh::FE< 2, MONOMIAL >::n_dofs_at_node	(	const ElemType	,
		const Order	,
		const unsigned	int
	)

Definition at line 389 of file fe_monomial.C.

389 { return 0; }

template<>

unsigned int libMesh::FE< 3, MONOMIAL >::n_dofs_at_node	(	const ElemType	,
		const Order	,
		const unsigned	int
	)

Definition at line 390 of file fe_monomial.C.

390 { return 0; }

template<>

unsigned int libMesh::FE< 0, BERNSTEIN >::n_dofs_at_node	(	const ElemType	t,
		const Order	o,
		const unsigned int	n
	)

Definition at line 418 of file fe_bernstein.C.

418 { return bernstein_n_dofs_at_node(t, o, n); }

template<>

unsigned int libMesh::FE< 1, BERNSTEIN >::n_dofs_at_node	(	const ElemType	t,
		const Order	o,
		const unsigned int	n
	)

Definition at line 419 of file fe_bernstein.C.

419 { return bernstein_n_dofs_at_node(t, o, n); }

template<>

unsigned int libMesh::FE< 2, BERNSTEIN >::n_dofs_at_node	(	const ElemType	t,
		const Order	o,
		const unsigned int	n
	)

Definition at line 420 of file fe_bernstein.C.

420 { return bernstein_n_dofs_at_node(t, o, n); }

template<>

unsigned int libMesh::FE< 3, BERNSTEIN >::n_dofs_at_node	(	const ElemType	t,
		const Order	o,
		const unsigned int	n
	)

Definition at line 421 of file fe_bernstein.C.

421 { return bernstein_n_dofs_at_node(t, o, n); }

template<>

unsigned int libMesh::FE< 0, L2_LAGRANGE >::n_dofs_at_node	(	const ElemType	,
		const Order	,
		const unsigned	int
	)

Definition at line 462 of file fe_l2_lagrange.C.

462 { return 0; }

template<>

unsigned int libMesh::FE< 1, L2_LAGRANGE >::n_dofs_at_node	(	const ElemType	,
		const Order	,
		const unsigned	int
	)

Definition at line 463 of file fe_l2_lagrange.C.

463 { return 0; }

template<>

unsigned int libMesh::FE< 2, L2_LAGRANGE >::n_dofs_at_node	(	const ElemType	,
		const Order	,
		const unsigned	int
	)

Definition at line 464 of file fe_l2_lagrange.C.

464 { return 0; }

template<>

unsigned int libMesh::FE< 3, L2_LAGRANGE >::n_dofs_at_node	(	const ElemType	,
		const Order	,
		const unsigned	int
	)

Definition at line 465 of file fe_l2_lagrange.C.

465 { return 0; }

template<>

unsigned int libMesh::FE< 0, NEDELEC_ONE >::n_dofs_at_node	(	const ElemType	,
		const Order	,
		const unsigned	int
	)

Definition at line 536 of file fe_nedelec_one.C.

536 { NEDELEC_LOW_D_ERROR_MESSAGE }

template<>

unsigned int libMesh::FE< 1, NEDELEC_ONE >::n_dofs_at_node	(	const ElemType	,
		const Order	,
		const unsigned	int
	)

Definition at line 537 of file fe_nedelec_one.C.

537 { NEDELEC_LOW_D_ERROR_MESSAGE }

template<>

unsigned int libMesh::FE< 2, NEDELEC_ONE >::n_dofs_at_node	(	const ElemType	t,
		const Order	o,
		const unsigned int	n
	)

Definition at line 538 of file fe_nedelec_one.C.

538 { return nedelec_one_n_dofs_at_node(t, o, n); }

template<>

unsigned int libMesh::FE< 3, NEDELEC_ONE >::n_dofs_at_node	(	const ElemType	t,
		const Order	o,
		const unsigned int	n
	)

Definition at line 539 of file fe_nedelec_one.C.

539 { return nedelec_one_n_dofs_at_node(t, o, n); }

template<>

unsigned int libMesh::FE< 0, LAGRANGE >::n_dofs_at_node	(	const ElemType	t,
		const Order	o,
		const unsigned int	n
	)

Definition at line 864 of file fe_lagrange.C.

864 { return lagrange_n_dofs_at_node(t, o, n); }

template<>

unsigned int libMesh::FE< 1, LAGRANGE >::n_dofs_at_node	(	const ElemType	t,
		const Order	o,
		const unsigned int	n
	)

Definition at line 865 of file fe_lagrange.C.

865 { return lagrange_n_dofs_at_node(t, o, n); }

template<>

unsigned int libMesh::FE< 2, LAGRANGE >::n_dofs_at_node	(	const ElemType	t,
		const Order	o,
		const unsigned int	n
	)

Definition at line 866 of file fe_lagrange.C.

866 { return lagrange_n_dofs_at_node(t, o, n); }

template<>

unsigned int libMesh::FE< 3, LAGRANGE >::n_dofs_at_node	(	const ElemType	t,
		const Order	o,
		const unsigned int	n
	)

Definition at line 867 of file fe_lagrange.C.

867 { return lagrange_n_dofs_at_node(t, o, n); }

template<>

unsigned int libMesh::FE< 0, XYZ >::n_dofs_at_node	(	const ElemType	,
		const Order	,
		const unsigned	int
	)

Definition at line 903 of file fe_xyz.C.

903 { return 0; }

template<>

unsigned int libMesh::FE< 1, XYZ >::n_dofs_at_node	(	const ElemType	,
		const Order	,
		const unsigned	int
	)

Definition at line 904 of file fe_xyz.C.

904 { return 0; }

template<>

unsigned int libMesh::FE< 2, XYZ >::n_dofs_at_node	(	const ElemType	,
		const Order	,
		const unsigned	int
	)

Definition at line 905 of file fe_xyz.C.

905 { return 0; }

template<>

unsigned int libMesh::FE< 3, XYZ >::n_dofs_at_node	(	const ElemType	,
		const Order	,
		const unsigned	int
	)

Definition at line 906 of file fe_xyz.C.

906 { return 0; }

template<>

unsigned int libMesh::FE< 0, LAGRANGE_VEC >::n_dofs_at_node	(	const ElemType	t,
		const Order	o,
		const unsigned int	n
	)

Definition at line 913 of file fe_lagrange_vec.C.

References libMesh::FE< Dim, T >::n_dofs_at_node().

913 { return FE<0,LAGRANGE>::n_dofs_at_node(t,o,n); }

static unsigned int n_dofs_at_node(const ElemType t, const Order o, const unsigned int n)

template<>

unsigned int libMesh::FE< 1, LAGRANGE_VEC >::n_dofs_at_node	(	const ElemType	t,
		const Order	o,
		const unsigned int	n
	)

Definition at line 914 of file fe_lagrange_vec.C.

References libMesh::FE< Dim, T >::n_dofs_at_node().

914 { return FE<1,LAGRANGE>::n_dofs_at_node(t,o,n); }

static unsigned int n_dofs_at_node(const ElemType t, const Order o, const unsigned int n)

template<>

unsigned int libMesh::FE< 2, LAGRANGE_VEC >::n_dofs_at_node	(	const ElemType	t,
		const Order	o,
		const unsigned int	n
	)

Definition at line 915 of file fe_lagrange_vec.C.

References libMesh::FE< Dim, T >::n_dofs_at_node().

915 { return 2*FE<2,LAGRANGE>::n_dofs_at_node(t,o,n); }

static unsigned int n_dofs_at_node(const ElemType t, const Order o, const unsigned int n)

template<>

unsigned int libMesh::FE< 3, LAGRANGE_VEC >::n_dofs_at_node	(	const ElemType	t,
		const Order	o,
		const unsigned int	n
	)

Definition at line 916 of file fe_lagrange_vec.C.

References libMesh::FE< Dim, T >::n_dofs_at_node().

916 { return 3*FE<2,LAGRANGE>::n_dofs_at_node(t,o,n); }

References libMesh::ReferenceCounter::_n_objects, libMesh::ReferenceCounter::disable_print_counter_info(), libMesh::ReferenceCounter::enable_print_counter_info(), libMesh::ReferenceCounter::increment_constructor_count(), libMesh::ReferenceCounter::increment_destructor_count(), and libMesh::Quality::name().

static unsigned int n_dofs_at_node(const ElemType t, const Order o, const unsigned int n)

template<>

unsigned int libMesh::FE< 2, SUBDIVISION >::n_dofs_at_node	(	const ElemType	,
		const Order	,
		const unsigned	int
	)

Definition at line 918 of file fe_subdivision_2D.C.

918 { return 1; }

template<>

unsigned int libMesh::FE< 0, SZABAB >::n_dofs_at_node	(	const ElemType	t,
		const Order	o,
		const unsigned int	n
	)

Definition at line 1267 of file fe_szabab.C.

1267 { return szabab_n_dofs_at_node(t, o, n); }

template<>

unsigned int libMesh::FE< 1, SZABAB >::n_dofs_at_node	(	const ElemType	t,
		const Order	o,
		const unsigned int	n
	)

Definition at line 1268 of file fe_szabab.C.

1268 { return szabab_n_dofs_at_node(t, o, n); }

template<>

unsigned int libMesh::FE< 2, SZABAB >::n_dofs_at_node	(	const ElemType	t,
		const Order	o,
		const unsigned int	n
	)

Definition at line 1269 of file fe_szabab.C.

1269 { return szabab_n_dofs_at_node(t, o, n); }

template<>

unsigned int libMesh::FE< 3, SZABAB >::n_dofs_at_node	(	const ElemType	t,
		const Order	o,
		const unsigned int	n
	)

Definition at line 1270 of file fe_szabab.C.

1270 { return szabab_n_dofs_at_node(t, o, n); }

template<>

unsigned int libMesh::FE< 0, SCALAR >::n_dofs_per_elem	(	const ElemType	,
		const Order
	)

Definition at line 101 of file fe_scalar.C.

101 { return 0; }

template<>

unsigned int libMesh::FE< 1, SCALAR >::n_dofs_per_elem	(	const ElemType	,
		const Order
	)

Definition at line 102 of file fe_scalar.C.

102 { return 0; }

template<>

unsigned int libMesh::FE< 2, SCALAR >::n_dofs_per_elem	(	const ElemType	,
		const Order
	)

Definition at line 103 of file fe_scalar.C.

103 { return 0; }

template<>

unsigned int libMesh::FE< 3, SCALAR >::n_dofs_per_elem	(	const ElemType	,
		const Order
	)

Definition at line 104 of file fe_scalar.C.

104 { return 0; }

template<>

unsigned int libMesh::FE< 0, L2_HIERARCHIC >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 188 of file fe_l2_hierarchic.C.

188 { return l2_hierarchic_n_dofs(t, o); }

template<>

unsigned int libMesh::FE< 1, L2_HIERARCHIC >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 189 of file fe_l2_hierarchic.C.

189 { return l2_hierarchic_n_dofs(t, o); }

template<>

unsigned int libMesh::FE< 2, L2_HIERARCHIC >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 190 of file fe_l2_hierarchic.C.

190 { return l2_hierarchic_n_dofs(t, o); }

template<>

unsigned int libMesh::FE< 3, L2_HIERARCHIC >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 191 of file fe_l2_hierarchic.C.

191 { return l2_hierarchic_n_dofs(t, o); }

template<unsigned int Dim, FEFamily T>

static unsigned int libMesh::FE< Dim, T >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

static

Returns: The number of dofs interior to the element, not associated with any interior nodes.

On a p-refined element, o should be the total order of the element.

template<>

unsigned int libMesh::FE< 0, CLOUGH >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 293 of file fe_clough.C.

293 { return clough_n_dofs_per_elem(t, o); }

template<>

unsigned int libMesh::FE< 1, CLOUGH >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 294 of file fe_clough.C.

294 { return clough_n_dofs_per_elem(t, o); }

template<>

unsigned int libMesh::FE< 2, CLOUGH >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 295 of file fe_clough.C.

295 { return clough_n_dofs_per_elem(t, o); }

template<>

unsigned int libMesh::FE< 3, CLOUGH >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 296 of file fe_clough.C.

296 { return clough_n_dofs_per_elem(t, o); }

template<>

unsigned int libMesh::FE< 0, HERMITE >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 333 of file fe_hermite.C.

333 { return hermite_n_dofs_per_elem(t, o); }

template<>

unsigned int libMesh::FE< 1, HERMITE >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 334 of file fe_hermite.C.

334 { return hermite_n_dofs_per_elem(t, o); }

template<>

unsigned int libMesh::FE< 2, HERMITE >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 335 of file fe_hermite.C.

335 { return hermite_n_dofs_per_elem(t, o); }

template<>

unsigned int libMesh::FE< 3, HERMITE >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 336 of file fe_hermite.C.

336 { return hermite_n_dofs_per_elem(t, o); }

template<>

unsigned int libMesh::FE< 0, HIERARCHIC >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 361 of file fe_hierarchic.C.

361 { return hierarchic_n_dofs_per_elem(t, o); }

template<>

unsigned int libMesh::FE< 1, HIERARCHIC >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 362 of file fe_hierarchic.C.

362 { return hierarchic_n_dofs_per_elem(t, o); }

template<>

unsigned int libMesh::FE< 2, HIERARCHIC >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 363 of file fe_hierarchic.C.

363 { return hierarchic_n_dofs_per_elem(t, o); }

template<>

unsigned int libMesh::FE< 3, HIERARCHIC >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 364 of file fe_hierarchic.C.

364 { return hierarchic_n_dofs_per_elem(t, o); }

template<>

unsigned int libMesh::FE< 0, MONOMIAL >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 393 of file fe_monomial.C.

393 { return monomial_n_dofs(t, o); }

template<>

unsigned int libMesh::FE< 1, MONOMIAL >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 394 of file fe_monomial.C.

394 { return monomial_n_dofs(t, o); }

template<>

unsigned int libMesh::FE< 2, MONOMIAL >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 395 of file fe_monomial.C.

395 { return monomial_n_dofs(t, o); }

template<>

unsigned int libMesh::FE< 3, MONOMIAL >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 396 of file fe_monomial.C.

396 { return monomial_n_dofs(t, o); }

template<>

unsigned int libMesh::FE< 0, BERNSTEIN >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 424 of file fe_bernstein.C.

424 { return bernstein_n_dofs_per_elem(t, o); }

template<>

unsigned int libMesh::FE< 1, BERNSTEIN >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 425 of file fe_bernstein.C.

425 { return bernstein_n_dofs_per_elem(t, o); }

template<>

unsigned int libMesh::FE< 2, BERNSTEIN >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 426 of file fe_bernstein.C.

426 { return bernstein_n_dofs_per_elem(t, o); }

template<>

unsigned int libMesh::FE< 3, BERNSTEIN >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 427 of file fe_bernstein.C.

427 { return bernstein_n_dofs_per_elem(t, o); }

template<>

unsigned int libMesh::FE< 0, L2_LAGRANGE >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 469 of file fe_l2_lagrange.C.

469 { return l2_lagrange_n_dofs(t, o); }

template<>

unsigned int libMesh::FE< 1, L2_LAGRANGE >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 470 of file fe_l2_lagrange.C.

470 { return l2_lagrange_n_dofs(t, o); }

template<>

unsigned int libMesh::FE< 2, L2_LAGRANGE >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 471 of file fe_l2_lagrange.C.

471 { return l2_lagrange_n_dofs(t, o); }

template<>

unsigned int libMesh::FE< 3, L2_LAGRANGE >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 472 of file fe_l2_lagrange.C.

472 { return l2_lagrange_n_dofs(t, o); }

template<>

unsigned int libMesh::FE< 0, NEDELEC_ONE >::n_dofs_per_elem	(	const ElemType	,
		const Order
	)

Definition at line 544 of file fe_nedelec_one.C.

544 { NEDELEC_LOW_D_ERROR_MESSAGE }

template<>

unsigned int libMesh::FE< 1, NEDELEC_ONE >::n_dofs_per_elem	(	const ElemType	,
		const Order
	)

Definition at line 545 of file fe_nedelec_one.C.

545 { NEDELEC_LOW_D_ERROR_MESSAGE }

template<>

unsigned int libMesh::FE< 2, NEDELEC_ONE >::n_dofs_per_elem	(	const ElemType	,
		const Order
	)

Definition at line 546 of file fe_nedelec_one.C.

546 { return 0; }

template<>

unsigned int libMesh::FE< 3, NEDELEC_ONE >::n_dofs_per_elem	(	const ElemType	,
		const Order
	)

Definition at line 547 of file fe_nedelec_one.C.

547 { return 0; }

template<>

unsigned int libMesh::FE< 0, LAGRANGE >::n_dofs_per_elem	(	const ElemType	,
		const Order
	)

Definition at line 872 of file fe_lagrange.C.

872 { return 0; }

template<>

unsigned int libMesh::FE< 1, LAGRANGE >::n_dofs_per_elem	(	const ElemType	,
		const Order
	)

Definition at line 873 of file fe_lagrange.C.

873 { return 0; }

template<>

unsigned int libMesh::FE< 2, LAGRANGE >::n_dofs_per_elem	(	const ElemType	,
		const Order
	)

Definition at line 874 of file fe_lagrange.C.

874 { return 0; }

template<>

unsigned int libMesh::FE< 3, LAGRANGE >::n_dofs_per_elem	(	const ElemType	,
		const Order
	)

Definition at line 875 of file fe_lagrange.C.

875 { return 0; }

template<>

unsigned int libMesh::FE< 0, XYZ >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 909 of file fe_xyz.C.

909 { return xyz_n_dofs_per_elem(t, o); }

template<>

unsigned int libMesh::FE< 1, XYZ >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 910 of file fe_xyz.C.

910 { return xyz_n_dofs_per_elem(t, o); }

template<>

unsigned int libMesh::FE< 2, XYZ >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 911 of file fe_xyz.C.

911 { return xyz_n_dofs_per_elem(t, o); }

template<>

unsigned int libMesh::FE< 3, XYZ >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 912 of file fe_xyz.C.

912 { return xyz_n_dofs_per_elem(t, o); }

template<>

unsigned int libMesh::FE< 2, SUBDIVISION >::n_dofs_per_elem	(	const ElemType	,
		const Order
	)

Definition at line 921 of file fe_subdivision_2D.C.

921 { return 0; }

template<>

unsigned int libMesh::FE< 0, LAGRANGE_VEC >::n_dofs_per_elem	(	const ElemType	,
		const Order
	)

Definition at line 921 of file fe_lagrange_vec.C.

921 { return 0; }

template<>

unsigned int libMesh::FE< 1, LAGRANGE_VEC >::n_dofs_per_elem	(	const ElemType	,
		const Order
	)

Definition at line 922 of file fe_lagrange_vec.C.

922 { return 0; }

template<>

unsigned int libMesh::FE< 2, LAGRANGE_VEC >::n_dofs_per_elem	(	const ElemType	,
		const Order
	)

Definition at line 923 of file fe_lagrange_vec.C.

923 { return 0; }

template<>

unsigned int libMesh::FE< 3, LAGRANGE_VEC >::n_dofs_per_elem	(	const ElemType	,
		const Order
	)

Definition at line 924 of file fe_lagrange_vec.C.

924 { return 0; }

template<>

unsigned int libMesh::FE< 0, SZABAB >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 1273 of file fe_szabab.C.

1273 { return szabab_n_dofs_per_elem(t, o); }

template<>

unsigned int libMesh::FE< 1, SZABAB >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 1274 of file fe_szabab.C.

1274 { return szabab_n_dofs_per_elem(t, o); }

template<>

unsigned int libMesh::FE< 2, SZABAB >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 1275 of file fe_szabab.C.

1275 { return szabab_n_dofs_per_elem(t, o); }

template<>

unsigned int libMesh::FE< 3, SZABAB >::n_dofs_per_elem	(	const ElemType	t,
		const Order	o
	)

Definition at line 1276 of file fe_szabab.C.

1276 { return szabab_n_dofs_per_elem(t, o); }

static unsigned int libMesh::ReferenceCounter::n_objects ( )

inlinestaticinherited

Prints the number of outstanding (created, but not yet destroyed) objects.

Definition at line 85 of file reference_counter.h.

Referenced by libMesh::System::hide_output(), and libMesh::LibMeshInit::LibMeshInit().

86 { return _n_objects; }

libMesh::ReferenceCounter::_n_objects

static Threads::atomic< unsigned int > _n_objects

Definition: reference_counter.h:132

template<unsigned int Dim, FEFamily T>

unsigned int libMesh::FE< Dim, T >::n_quadrature_points ( ) const

virtual

Returns: The total number of quadrature points. Call this to get an upper bound for the for loop in your simulation for matrix assembly of the current element.

Implements libMesh::FEAbstract.

Definition at line 55 of file fe.C.

References libMesh::libmesh_assert().

 {
   libmesh_assert(this->qrule);
   return this->qrule->n_points();
 }

template<unsigned int Dim, FEFamily T>

unsigned int libMesh::FE< Dim, T >::n_shape_functions ( ) const

virtual

Returns: The number of shape functions associated with this finite element.

Implements libMesh::FEAbstract.

Definition at line 36 of file fe.C.

Referenced by libMesh::FEMap::compute_face_map(), libMesh::FEMap::init_edge_shape_functions(), libMesh::FEMap::init_face_shape_functions(), libMesh::FEMap::init_reference_to_physical_map(), libMesh::FE< Dim, T >::map(), libMesh::FE< Dim, T >::map_eta(), libMesh::FE< Dim, T >::map_xi(), libMesh::FE< Dim, T >::map_zeta(), and libMesh::InfFE< Dim, T_radial, T_map >::Base::n_base_mapping_sf().

 {
   return FE<Dim,T>::n_dofs (this->elem_type,
                             static_cast<Order>(this->fe_type.order + this->_p_level));
 }

template<unsigned int Dim, FEFamily T>

static unsigned int libMesh::FE< Dim, T >::n_shape_functions	(	const ElemType	t,
		const Order	o
	)

inlinestatic

Returns: The number of shape functions associated with a finite element of type t and approximation order o.

On a p-refined element, o should be the total order of the element.

Definition at line 228 of file fe.h.

230 { return FE<Dim,T>::n_dofs (t,o); }

static unsigned int n_dofs(const ElemType t, const Order o)

template<>

void libMesh::FE< 0, SCALAR >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 58 of file fe_scalar.C.

62 { scalar_nodal_soln(elem, order, elem_soln, nodal_soln); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

template<>

void libMesh::FE< 1, SCALAR >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 65 of file fe_scalar.C.

69 { scalar_nodal_soln(elem, order, elem_soln, nodal_soln); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

template<>

void libMesh::FE< 2, SCALAR >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 72 of file fe_scalar.C.

76 { scalar_nodal_soln(elem, order, elem_soln, nodal_soln); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

template<>

void libMesh::FE< 3, SCALAR >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 79 of file fe_scalar.C.

83 { scalar_nodal_soln(elem, order, elem_soln, nodal_soln); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

template<>

void libMesh::FE< 0, L2_HIERARCHIC >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 147 of file fe_l2_hierarchic.C.

151 { l2_hierarchic_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/0); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

template<>

void libMesh::FE< 1, L2_HIERARCHIC >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 154 of file fe_l2_hierarchic.C.

158 { l2_hierarchic_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/1); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

template<>

void libMesh::FE< 2, L2_HIERARCHIC >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 161 of file fe_l2_hierarchic.C.

165 { l2_hierarchic_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/2); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

template<>

void libMesh::FE< 3, L2_HIERARCHIC >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 168 of file fe_l2_hierarchic.C.

172 { l2_hierarchic_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/3); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

template<unsigned int Dim, FEFamily T>

static void libMesh::FE< Dim, T >::nodal_soln	(	const Elem *	elem,
		const Order	o,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

static

Build the nodal soln from the element soln. This is the solution that will be plotted.

On a p-refined element, o should be the base order of the element.

Referenced by libMesh::FE< Dim, T >::nodal_soln().

template<>

void libMesh::FE< 0, CLOUGH >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 251 of file fe_clough.C.

255 { clough_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/0); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

template<>

void libMesh::FE< 1, CLOUGH >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 258 of file fe_clough.C.

262 { clough_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/1); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

template<>

void libMesh::FE< 2, CLOUGH >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 265 of file fe_clough.C.

269 { clough_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/2); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

template<>

void libMesh::FE< 3, CLOUGH >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 272 of file fe_clough.C.

276 { clough_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/3); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

template<>

void libMesh::FE< 0, HERMITE >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 287 of file fe_hermite.C.

291 { hermite_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/0); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

template<>

void libMesh::FE< 1, HERMITE >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 294 of file fe_hermite.C.

298 { hermite_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/1); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

template<>

void libMesh::FE< 2, HERMITE >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 301 of file fe_hermite.C.

305 { hermite_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/2); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

template<>

void libMesh::FE< 3, HERMITE >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 308 of file fe_hermite.C.

312 { hermite_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/3); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

template<>

void libMesh::FE< 0, HIERARCHIC >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 320 of file fe_hierarchic.C.

324 { hierarchic_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/0); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

template<>

void libMesh::FE< 1, HIERARCHIC >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 327 of file fe_hierarchic.C.

331 { hierarchic_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/1); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

template<>

void libMesh::FE< 2, HIERARCHIC >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 334 of file fe_hierarchic.C.

338 { hierarchic_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/2); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

template<>

void libMesh::FE< 3, HIERARCHIC >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 341 of file fe_hierarchic.C.

345 { hierarchic_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/3); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

template<>

void libMesh::FE< 0, MONOMIAL >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 351 of file fe_monomial.C.

355 { monomial_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/0); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

template<>

void libMesh::FE< 1, MONOMIAL >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 358 of file fe_monomial.C.

362 { monomial_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/1); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

template<>

void libMesh::FE< 2, MONOMIAL >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 365 of file fe_monomial.C.

369 { monomial_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/2); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

template<>

void libMesh::FE< 3, MONOMIAL >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 372 of file fe_monomial.C.

376 { monomial_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/3); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

template<>

void libMesh::FE< 0, BERNSTEIN >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 383 of file fe_bernstein.C.

387 { bernstein_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/0); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

template<>

void libMesh::FE< 1, BERNSTEIN >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 390 of file fe_bernstein.C.

394 { bernstein_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/1); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

template<>

void libMesh::FE< 2, BERNSTEIN >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 397 of file fe_bernstein.C.

401 { bernstein_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/2); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

template<>

void libMesh::FE< 3, BERNSTEIN >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 404 of file fe_bernstein.C.

408 { bernstein_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/3); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

template<>

void libMesh::FE< 0, L2_LAGRANGE >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 424 of file fe_l2_lagrange.C.

428 { l2_lagrange_nodal_soln(elem, order, elem_soln, nodal_soln); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

template<>

void libMesh::FE< 1, L2_LAGRANGE >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 431 of file fe_l2_lagrange.C.

435 { l2_lagrange_nodal_soln(elem, order, elem_soln, nodal_soln); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

template<>

void libMesh::FE< 2, L2_LAGRANGE >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 438 of file fe_l2_lagrange.C.

442 { l2_lagrange_nodal_soln(elem, order, elem_soln, nodal_soln); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

template<>

void libMesh::FE< 3, L2_LAGRANGE >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 445 of file fe_l2_lagrange.C.

449 { l2_lagrange_nodal_soln(elem, order, elem_soln, nodal_soln); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

template<>

void libMesh::FE< 0, NEDELEC_ONE >::nodal_soln	(	const Elem *	,
		const Order	,
		const std::vector< Number > &	,
		std::vector< Number > &
	)

Definition at line 497 of file fe_nedelec_one.C.

501 { NEDELEC_LOW_D_ERROR_MESSAGE }

template<>

void libMesh::FE< 1, NEDELEC_ONE >::nodal_soln	(	const Elem *	,
		const Order	,
		const std::vector< Number > &	,
		std::vector< Number > &
	)

Definition at line 504 of file fe_nedelec_one.C.

508 { NEDELEC_LOW_D_ERROR_MESSAGE }

template<>

void libMesh::FE< 0, LAGRANGE_VEC >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 507 of file fe_lagrange_vec.C.

References libMesh::FE< Dim, T >::nodal_soln().

511 { FE<0,LAGRANGE>::nodal_soln(elem, order, elem_soln, nodal_soln); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

template<>

void libMesh::FE< 2, NEDELEC_ONE >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 511 of file fe_nedelec_one.C.

515 { nedelec_one_nodal_soln(elem, order, elem_soln, 2 /*dim*/, nodal_soln); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

template<>

void libMesh::FE< 1, LAGRANGE_VEC >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 514 of file fe_lagrange_vec.C.

References libMesh::FE< Dim, T >::nodal_soln().

518 { FE<1,LAGRANGE>::nodal_soln(elem, order, elem_soln, nodal_soln); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

template<>

void libMesh::FE< 3, NEDELEC_ONE >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 518 of file fe_nedelec_one.C.

522 { nedelec_one_nodal_soln(elem, order, elem_soln, 3 /*dim*/, nodal_soln); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

template<>

void libMesh::FE< 2, LAGRANGE_VEC >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 521 of file fe_lagrange_vec.C.

525 { lagrange_vec_nodal_soln(elem, order, elem_soln, 2 /*dimension*/, nodal_soln); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

template<>

void libMesh::FE< 3, LAGRANGE_VEC >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 528 of file fe_lagrange_vec.C.

532 { lagrange_vec_nodal_soln(elem, order, elem_soln, 3 /*dimension*/, nodal_soln); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

template<>

void libMesh::FE< 0, LAGRANGE >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 825 of file fe_lagrange.C.

829 { lagrange_nodal_soln(elem, order, elem_soln, nodal_soln); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

template<>

void libMesh::FE< 1, LAGRANGE >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 832 of file fe_lagrange.C.

836 { lagrange_nodal_soln(elem, order, elem_soln, nodal_soln); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

template<>

void libMesh::FE< 2, SUBDIVISION >::nodal_soln	(	const Elem *	elem,
		const Order	,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 836 of file fe_subdivision_2D.C.

References libMesh::libmesh_assert(), libMesh::Tri3Subdivision::local_node_number(), libMesh::TRI3SUBDIVISION, and libMesh::Elem::type().

 {
   libmesh_assert(elem);
   libmesh_assert_equal_to(elem->type(), TRI3SUBDIVISION);
   const Tri3Subdivision * sd_elem = static_cast<const Tri3Subdivision *>(elem);
 
   nodal_soln.resize(3); // three nodes per element
 
   // Ghost nodes are auxiliary.
   if (sd_elem->is_ghost())
     {
       nodal_soln[0] = 0;
       nodal_soln[1] = 0;
       nodal_soln[2] = 0;
       return;
     }
 
   // First node (node 0 in the element patch):
   unsigned int j = sd_elem->local_node_number(sd_elem->get_ordered_node(0)->id());
   nodal_soln[j] = elem_soln[0];
 
   // Second node (node 1 in the element patch):
   j = sd_elem->local_node_number(sd_elem->get_ordered_node(1)->id());
   nodal_soln[j] = elem_soln[1];
 
   // Third node (node 'valence' in the element patch):
   j = sd_elem->local_node_number(sd_elem->get_ordered_node(2)->id());
   nodal_soln[j] = elem_soln[sd_elem->get_ordered_valence(0)];
 }

template<>

void libMesh::FE< 2, LAGRANGE >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 839 of file fe_lagrange.C.

843 { lagrange_nodal_soln(elem, order, elem_soln, nodal_soln); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

template<>

void libMesh::FE< 3, LAGRANGE >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 846 of file fe_lagrange.C.

850 { lagrange_nodal_soln(elem, order, elem_soln, nodal_soln); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

template<>

void libMesh::FE< 0, XYZ >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 866 of file fe_xyz.C.

870 { xyz_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/0); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

template<>

void libMesh::FE< 1, XYZ >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 873 of file fe_xyz.C.

877 { xyz_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/1); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

template<>

void libMesh::FE< 2, XYZ >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 880 of file fe_xyz.C.

884 { xyz_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/2); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

template<>

void libMesh::FE< 3, XYZ >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 887 of file fe_xyz.C.

891 { xyz_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/3); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

template<>

void libMesh::FE< 0, SZABAB >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 1232 of file fe_szabab.C.

1236 { szabab_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/0); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

template<>

void libMesh::FE< 1, SZABAB >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 1239 of file fe_szabab.C.

1243 { szabab_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/1); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

template<>

void libMesh::FE< 2, SZABAB >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 1246 of file fe_szabab.C.

1250 { szabab_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/2); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

template<>

void libMesh::FE< 3, SZABAB >::nodal_soln	(	const Elem *	elem,
		const Order	order,
		const std::vector< Number > &	elem_soln,
		std::vector< Number > &	nodal_soln
	)

Definition at line 1253 of file fe_szabab.C.

1257 { szabab_nodal_soln(elem, order, elem_soln, nodal_soln, /*Dim=*/3); }

static void nodal_soln(const Elem *elem, const Order o, const std::vector< Number > &elem_soln, std::vector< Number > &nodal_soln)

bool libMesh::FEAbstract::on_reference_element	(	const Point &	p,
		const ElemType	t,
		const Real	eps = `TOLERANCE`
	)

staticinherited

Returns: true if the point p is located on the reference element for element type t, false otherwise. Since we are doing floating point comparisons here the parameter eps can be specified to indicate a tolerance. For example, $x \le 1$ becomes $x \le 1 + \epsilon$ .

Definition at line 556 of file fe_abstract.C.

References libMesh::EDGE2, libMesh::EDGE3, libMesh::EDGE4, libMesh::HEX20, libMesh::HEX27, libMesh::HEX8, libMesh::INFHEX8, libMesh::INFPRISM6, libMesh::NODEELEM, libMesh::PRISM15, libMesh::PRISM18, libMesh::PRISM6, libMesh::PYRAMID13, libMesh::PYRAMID14, libMesh::PYRAMID5, libMesh::QUAD4, libMesh::QUAD8, libMesh::QUAD9, libMesh::QUADSHELL4, libMesh::Real, libMesh::TET10, libMesh::TET4, libMesh::TRI3, libMesh::TRI6, and libMesh::TRISHELL3.

Referenced by libMesh::FEInterface::ifem_on_reference_element(), libMesh::FE< Dim, T >::inverse_map(), and libMesh::FEInterface::on_reference_element().

 {
   libmesh_assert_greater_equal (eps, 0.);
 
   const Real xi   = p(0);
 #if LIBMESH_DIM > 1
   const Real eta  = p(1);
 #else
   const Real eta  = 0.;
 #endif
 #if LIBMESH_DIM > 2
   const Real zeta = p(2);
 #else
   const Real zeta  = 0.;
 #endif
 
   switch (t)
     {
     case NODEELEM:
       {
         return (!xi && !eta && !zeta);
       }
     case EDGE2:
     case EDGE3:
     case EDGE4:
       {
         // The reference 1D element is [-1,1].
         if ((xi >= -1.-eps) &&
             (xi <=  1.+eps))
           return true;
 
         return false;
       }
 
 
     case TRI3:
     case TRISHELL3:
     case TRI6:
       {
         // The reference triangle is isocoles
         // and is bound by xi=0, eta=0, and xi+eta=1.
         if ((xi  >= 0.-eps) &&
             (eta >= 0.-eps) &&
             ((xi + eta) <= 1.+eps))
           return true;
 
         return false;
       }
 
 
     case QUAD4:
     case QUADSHELL4:
     case QUAD8:
     case QUAD9:
       {
         // The reference quadrilateral element is [-1,1]^2.
         if ((xi  >= -1.-eps) &&
             (xi  <=  1.+eps) &&
             (eta >= -1.-eps) &&
             (eta <=  1.+eps))
           return true;
 
         return false;
       }
 
 
     case TET4:
     case TET10:
       {
         // The reference tetrahedral is isocoles
         // and is bound by xi=0, eta=0, zeta=0,
         // and xi+eta+zeta=1.
         if ((xi   >= 0.-eps) &&
             (eta  >= 0.-eps) &&
             (zeta >= 0.-eps) &&
             ((xi + eta + zeta) <= 1.+eps))
           return true;
 
         return false;
       }
 
 
     case HEX8:
     case HEX20:
     case HEX27:
       {
         /*
           if ((xi   >= -1.) &&
           (xi   <=  1.) &&
           (eta  >= -1.) &&
           (eta  <=  1.) &&
           (zeta >= -1.) &&
           (zeta <=  1.))
           return true;
         */
 
         // The reference hexahedral element is [-1,1]^3.
         if ((xi   >= -1.-eps) &&
             (xi   <=  1.+eps) &&
             (eta  >= -1.-eps) &&
             (eta  <=  1.+eps) &&
             (zeta >= -1.-eps) &&
             (zeta <=  1.+eps))
           {
             //    libMesh::out << "Strange Point:\n";
             //    p.print();
             return true;
           }
 
         return false;
       }
 
     case PRISM6:
     case PRISM15:
     case PRISM18:
       {
         // Figure this one out...
         // inside the reference triange with zeta in [-1,1]
         if ((xi   >=  0.-eps) &&
             (eta  >=  0.-eps) &&
             (zeta >= -1.-eps) &&
             (zeta <=  1.+eps) &&
             ((xi + eta) <= 1.+eps))
           return true;
 
         return false;
       }
 
 
     case PYRAMID5:
     case PYRAMID13:
     case PYRAMID14:
       {
         // Check that the point is on the same side of all the faces
         // by testing whether:
         //
         // n_i.(x - x_i) <= 0
         //
         // for each i, where:
         //   n_i is the outward normal of face i,
         //   x_i is a point on face i.
         if ((-eta - 1. + zeta <= 0.+eps) &&
             (  xi - 1. + zeta <= 0.+eps) &&
             ( eta - 1. + zeta <= 0.+eps) &&
             ( -xi - 1. + zeta <= 0.+eps) &&
             (            zeta >= 0.-eps))
           return true;
 
         return false;
       }
 
 #ifdef LIBMESH_ENABLE_INFINITE_ELEMENTS
     case INFHEX8:
       {
         // The reference infhex8 is a [-1,1]^3.
         if ((xi   >= -1.-eps) &&
             (xi   <=  1.+eps) &&
             (eta  >= -1.-eps) &&
             (eta  <=  1.+eps) &&
             (zeta >= -1.-eps) &&
             (zeta <=  1.+eps))
           {
             return true;
           }
         return false;
       }
 
     case INFPRISM6:
       {
         // inside the reference triange with zeta in [-1,1]
         if ((xi   >=  0.-eps) &&
             (eta  >=  0.-eps) &&
             (zeta >= -1.-eps) &&
             (zeta <=  1.+eps) &&
             ((xi + eta) <= 1.+eps))
           {
             return true;
           }
 
         return false;
       }
 #endif
 
     default:
       libmesh_error_msg("ERROR: Unknown element type " << t);
     }
 
   // If we get here then the point is _not_ in the
   // reference element.   Better return false.
 
   return false;
 }

void libMesh::FEGenericBase< FEOutputType< T >::type >::print_d2phi ( std::ostream & os ) const

virtualinherited

Prints the value of each shape function's second derivatives at each quadrature point.

Implements libMesh::FEAbstract.

void libMesh::FEGenericBase< FEOutputType< T >::type >::print_dphi ( std::ostream & os ) const

virtualinherited

Prints the value of each shape function's derivative at each quadrature point.

Implements libMesh::FEAbstract.

void libMesh::ReferenceCounter::print_info ( std::ostream & out = libMesh::out )

staticinherited

Prints the reference information, by default to libMesh::out.

Definition at line 88 of file reference_counter.C.

References libMesh::ReferenceCounter::_enable_print_counter, and libMesh::ReferenceCounter::get_info().

Referenced by libMesh::LibMeshInit::LibMeshInit().

 {
   if (_enable_print_counter)
     out_stream << ReferenceCounter::get_info();
 }

void libMesh::FEAbstract::print_info ( std::ostream & os ) const

inherited

Prints all the relevant information about the current element.

Definition at line 764 of file fe_abstract.C.

References libMesh::FEAbstract::print_dphi(), libMesh::FEAbstract::print_JxW(), libMesh::FEAbstract::print_phi(), and libMesh::FEAbstract::print_xyz().

Referenced by libMesh::FEAbstract::get_fe_map(), and libMesh::operator<<().

 {
   os << "phi[i][j]: Shape function i at quadrature pt. j" << std::endl;
   this->print_phi(os);
 
   os << "dphi[i][j]: Shape function i's gradient at quadrature pt. j" << std::endl;
   this->print_dphi(os);
 
   os << "XYZ locations of the quadrature pts." << std::endl;
   this->print_xyz(os);
 
   os << "Values of JxW at the quadrature pts." << std::endl;
   this->print_JxW(os);
 }

void libMesh::FEAbstract::print_JxW ( std::ostream & os ) const

inherited

Prints the Jacobian times the weight for each quadrature point.

Definition at line 751 of file fe_abstract.C.

Referenced by libMesh::FEAbstract::get_fe_map(), and libMesh::FEAbstract::print_info().

 {
   this->_fe_map->print_JxW(os);
 }

void libMesh::FEGenericBase< FEOutputType< T >::type >::print_phi ( std::ostream & os ) const

virtualinherited

Prints the value of each shape function at each quadrature point.

Implements libMesh::FEAbstract.

void libMesh::FEAbstract::print_xyz ( std::ostream & os ) const

inherited

Prints the spatial location of each quadrature point (on the physical element).

Definition at line 758 of file fe_abstract.C.

Referenced by libMesh::FEAbstract::get_fe_map(), and libMesh::FEAbstract::print_info().

 {
   this->_fe_map->print_xyz(os);
 }

template<unsigned int Dim, FEFamily T>

void libMesh::FE< Dim, T >::reinit	(	const Elem *	elem,
		const std::vector< Point > *const	pts = `libmesh_nullptr`,
		const std::vector< Real > *const	weights = `libmesh_nullptr`
	)

virtual

This is at the core of this class. Use this for each new element in the mesh. Reinitializes all the physical element-dependent data based on the current element elem. By default the shape functions and associated data are computed at the quadrature points specified by the quadrature rule qrule, but may be any points specified on the reference element specified in the optional argument pts.

Implements libMesh::FEAbstract.

Reimplemented in libMesh::FEXYZ< Dim >, and libMesh::FESubdivision.

Definition at line 115 of file fe.C.

References libMesh::INVALID_ELEM, libMesh::libmesh_assert(), libmesh_nullptr, libMesh::Elem::n_nodes(), libMesh::Elem::p_level(), libMesh::Elem::point(), libMesh::SCALAR, and libMesh::Elem::type().

Referenced by libMesh::FEMap::compute_edge_map(), and libMesh::FEXYZ< Dim >::reinit().

 {
   // We can be called with no element.  If we're evaluating SCALAR
   // dofs we'll still have work to do.
   // libmesh_assert(elem);
 
   // We're calculating now!  Time to determine what.
   this->determine_calculations();
 
   // Try to avoid calling init_shape_functions
   // even when shapes_need_reinit
   bool cached_nodes_still_fit = false;
 
   // Most of the hard work happens when we have an actual element
   if (elem)
     {
       // Initialize the shape functions at the user-specified
       // points
       if (pts != libmesh_nullptr)
         {
           // Set the type and p level for this element
           this->elem_type = elem->type();
           this->_p_level = elem->p_level();
 
           // Initialize the shape functions
           this->_fe_map->template init_reference_to_physical_map<Dim>
             (*pts, elem);
           this->init_shape_functions (*pts, elem);
 
           // The shape functions do not correspond to the qrule
           this->shapes_on_quadrature = false;
         }
 
       // If there are no user specified points, we use the
       // quadrature rule
 
       // update the type in accordance to the current cell
       // and reinit if the cell type has changed or (as in
       // the case of the hierarchics) the shape functions need
       // reinit, since they depend on the particular element shape
       else
         {
           libmesh_assert(this->qrule);
           this->qrule->init(elem->type(), elem->p_level());
 
           if (this->qrule->shapes_need_reinit())
             this->shapes_on_quadrature = false;
 
           if (this->elem_type != elem->type() ||
               this->_p_level != elem->p_level() ||
               !this->shapes_on_quadrature)
             {
               // Set the type and p level for this element
               this->elem_type = elem->type();
               this->_p_level = elem->p_level();
               // Initialize the shape functions
               this->_fe_map->template init_reference_to_physical_map<Dim>
                 (this->qrule->get_points(), elem);
               this->init_shape_functions (this->qrule->get_points(), elem);
 
               if (this->shapes_need_reinit())
                 {
                   cached_nodes.resize(elem->n_nodes());
                   for (unsigned int n = 0; n != elem->n_nodes(); ++n)
                     {
                       cached_nodes[n] = elem->point(n);
                     }
                 }
             }
           else
             {
               // libmesh_assert_greater (elem->n_nodes(), 1);
 
               cached_nodes_still_fit = true;
               if (cached_nodes.size() != elem->n_nodes())
                 cached_nodes_still_fit = false;
               else
                 for (unsigned int n = 1; n < elem->n_nodes(); ++n)
                   {
                     if (!(elem->point(n) - elem->point(0)).relative_fuzzy_equals
                         ((cached_nodes[n] - cached_nodes[0]), 1e-13))
                       {
                         cached_nodes_still_fit = false;
                         break;
                       }
                   }
 
               if (this->shapes_need_reinit() && !cached_nodes_still_fit)
                 {
                   this->_fe_map->template init_reference_to_physical_map<Dim>
                     (this->qrule->get_points(), elem);
                   this->init_shape_functions (this->qrule->get_points(), elem);
                   cached_nodes.resize(elem->n_nodes());
                   for (unsigned int n = 0; n != elem->n_nodes(); ++n)
                     cached_nodes[n] = elem->point(n);
                 }
             }
 
           // The shape functions correspond to the qrule
           this->shapes_on_quadrature = true;
         }
     }
   else // With no defined elem, so mapping or caching to
        // be done, and our "quadrature rule" is one point for nonlocal
        // (SCALAR) variables and zero points for local variables.
     {
       this->elem_type = INVALID_ELEM;
       this->_p_level = 0;
 
       if (!pts)
         {
           if (T == SCALAR)
             {
               this->qrule->get_points() =
                 std::vector<Point>(1,Point(0));
 
               this->qrule->get_weights() =
                 std::vector<Real>(1,1);
             }
           else
             {
               this->qrule->get_points().clear();
               this->qrule->get_weights().clear();
             }
 
           this->init_shape_functions (this->qrule->get_points(), elem);
         }
       else
         this->init_shape_functions (*pts, elem);
     }
 
   // Compute the map for this element.
   if (pts != libmesh_nullptr)
     {
       if (weights != libmesh_nullptr)
         {
           this->_fe_map->compute_map (this->dim, *weights, elem, this->calculate_d2phi);
         }
       else
         {
           std::vector<Real> dummy_weights (pts->size(), 1.);
           this->_fe_map->compute_map (this->dim, dummy_weights, elem, this->calculate_d2phi);
         }
     }
   else
     {
       this->_fe_map->compute_map (this->dim, this->qrule->get_weights(), elem, this->calculate_d2phi);
     }
 
   // Compute the shape functions and the derivatives at all of the
   // quadrature points.
   if (!cached_nodes_still_fit)
     {
       if (pts != libmesh_nullptr)
         this->compute_shape_functions (elem,*pts);
       else
         this->compute_shape_functions(elem,this->qrule->get_points());
     }
 }

template<unsigned int Dim, FEFamily T>

void libMesh::FE< Dim, T >::reinit	(	const Elem *	elem,
		const unsigned int	side,
		const Real	tolerance = `TOLERANCE`,
		const std::vector< Point > *const	pts = `libmesh_nullptr`,
		const std::vector< Real > *const	weights = `libmesh_nullptr`
	)

virtual

Reinitializes all the physical element-dependent data based on the side of face. The tolerance paremeter is passed to the involved call to inverse_map(). By default the shape functions and associated data are computed at the quadrature points specified by the quadrature rule qrule, but may be any points specified on the reference side element specified in the optional argument pts.

Implements libMesh::FEAbstract.

Reimplemented in libMesh::FEXYZ< Dim >, libMesh::FESubdivision, libMesh::FEXYZ< Dim >, and libMesh::FEXYZ< Dim >.

Definition at line 142 of file fe_boundary.C.

References libMesh::Elem::build_side_ptr(), libMesh::libmesh_assert(), libmesh_nullptr, std::max(), libMesh::Elem::neighbor_ptr(), libMesh::Elem::p_level(), side, and libMesh::Elem::type().

 {
   libmesh_assert(elem);
   libmesh_assert (this->qrule != libmesh_nullptr || pts != libmesh_nullptr);
   // We now do this for 1D elements!
   // libmesh_assert_not_equal_to (Dim, 1);
 
   // We're (possibly re-) calculating now!  FIXME - we currently
   // expect to be able to use side_map and JxW later, but we could
   // optimize further here.
   this->_fe_map->calculations_started = false;
   this->_fe_map->get_JxW();
   this->_fe_map->get_xyz();
   this->determine_calculations();
 
   // Build the side of interest
   const UniquePtr<const Elem> side(elem->build_side_ptr(s));
 
   // Find the max p_level to select
   // the right quadrature rule for side integration
   unsigned int side_p_level = elem->p_level();
   if (elem->neighbor_ptr(s) != libmesh_nullptr)
     side_p_level = std::max(side_p_level, elem->neighbor_ptr(s)->p_level());
 
   // Initialize the shape functions at the user-specified
   // points
   if (pts != libmesh_nullptr)
     {
       // The shape functions do not correspond to the qrule
       this->shapes_on_quadrature = false;
 
       // Initialize the face shape functions
       this->_fe_map->template init_face_shape_functions<Dim>(*pts, side.get());
 
       // Compute the Jacobian*Weight on the face for integration
       if (weights != libmesh_nullptr)
         {
           this->_fe_map->compute_face_map (Dim, *weights, side.get());
         }
       else
         {
           std::vector<Real> dummy_weights (pts->size(), 1.);
           this->_fe_map->compute_face_map (Dim, dummy_weights, side.get());
         }
     }
   // If there are no user specified points, we use the
   // quadrature rule
   else
     {
       // initialize quadrature rule
       this->qrule->init(side->type(), side_p_level);
 
       if (this->qrule->shapes_need_reinit())
         this->shapes_on_quadrature = false;
 
       // FIXME - could this break if the same FE object was used
       // for both volume and face integrals? - RHS
       // We might not need to reinitialize the shape functions
       if ((this->get_type() != elem->type())    ||
           (side->type() != last_side)           ||
           (this->get_p_level() != side_p_level) ||
           this->shapes_need_reinit()            ||
           !this->shapes_on_quadrature)
         {
           // Set the element type and p_level
           this->elem_type = elem->type();
 
           // Set the last_side
           last_side = side->type();
 
           // Set the last p level
           this->_p_level = side_p_level;
 
           // Initialize the face shape functions
           this->_fe_map->template init_face_shape_functions<Dim>(this->qrule->get_points(),  side.get());
         }
 
       // Compute the Jacobian*Weight on the face for integration
       this->_fe_map->compute_face_map (Dim, this->qrule->get_weights(), side.get());
 
       // The shape functions correspond to the qrule
       this->shapes_on_quadrature = true;
     }
 
   // make a copy of the Jacobian for integration
   const std::vector<Real> JxW_int(this->_fe_map->get_JxW());
 
   // make a copy of shape on quadrature info
   bool shapes_on_quadrature_side = this->shapes_on_quadrature;
 
   // Find where the integration points are located on the
   // full element.
   const std::vector<Point> * ref_qp;
   if (pts != libmesh_nullptr)
     ref_qp = pts;
   else
     ref_qp = &this->qrule->get_points();
 
   std::vector<Point> qp;
   this->side_map(elem, side.get(), s, *ref_qp, qp);
 
   // compute the shape function and derivative values
   // at the points qp
   this->reinit  (elem, &qp);
 
   this->shapes_on_quadrature = shapes_on_quadrature_side;
 
   // copy back old data
   this->_fe_map->get_JxW() = JxW_int;
 }

void libMesh::FEAbstract::set_fe_order ( int new_order )

inlineinherited

Sets the base FE order of the finite element.

Definition at line 425 of file fe_abstract.h.

References libMesh::FEAbstract::fe_type, libMesh::FEAbstract::get_continuity(), libMesh::FEAbstract::is_hierarchic(), and libMesh::FEType::order.

425 { fe_type.order = new_order; }

libMesh::FEType::order

OrderWrapper order

Definition: fe_type.h:197